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 hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2681 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2683 // can be used to determine if the device by index matches the cuda device by index
2684 // char name[100]; memset (name, 0, sizeof (name));
2685 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2692 log_info ("WARN: No NVML adapters found");
2700 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2702 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2704 if (iNumberAdapters
== 0)
2706 log_info ("WARN: No ADL adapters found.");
2715 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2717 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2718 ADLODParameters lpOdParameters;
2720 lpOdParameters.iSize = sizeof (ADLODParameters);
2721 size_t plevels_size = 0;
2723 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2725 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2726 __func__, iAdapterIndex,
2727 lpOdParameters.iNumberOfPerformanceLevels,
2728 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2729 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2731 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2733 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2735 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2737 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2739 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2740 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2741 __func__, iAdapterIndex, j,
2742 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2744 myfree (lpOdPerformanceLevels);
2750 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2752 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2754 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2756 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2758 return lpAdapterInfo
;
2763 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2766 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2770 for (uint i = 0; i < num_adl_adapters; i++)
2772 int opencl_bus_num = hm_device[i].busid;
2773 int opencl_dev_num = hm_device[i].devid;
2775 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2783 if (idx >= DEVICES_MAX) return -1;
2788 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2790 for (uint i = 0; i < opencl_num_devices; i++)
2792 cl_device_topology_amd device_topology;
2794 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2796 hm_device[i].busid = device_topology.pcie.bus;
2797 hm_device[i].devid = device_topology.pcie.device;
2802 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2804 // basically bubble sort
2806 for (int i
= 0; i
< num_adl_adapters
; i
++)
2808 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2810 // get info of adapter [x]
2812 u32 adapter_index_x
= valid_adl_device_list
[j
];
2813 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2815 u32 bus_num_x
= info_x
.iBusNumber
;
2816 u32 dev_num_x
= info_x
.iDeviceNumber
;
2818 // get info of adapter [y]
2820 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2821 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2823 u32 bus_num_y
= info_y
.iBusNumber
;
2824 u32 dev_num_y
= info_y
.iDeviceNumber
;
2828 if (bus_num_y
< bus_num_x
)
2832 else if (bus_num_y
== bus_num_x
)
2834 if (dev_num_y
< dev_num_x
)
2842 u32 temp
= valid_adl_device_list
[j
+ 1];
2844 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2845 valid_adl_device_list
[j
+ 0] = temp
;
2851 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2853 *num_adl_adapters
= 0;
2855 u32
*adl_adapters
= NULL
;
2857 int *bus_numbers
= NULL
;
2858 int *device_numbers
= NULL
;
2860 for (int i
= 0; i
< iNumberAdapters
; i
++)
2862 AdapterInfo info
= lpAdapterInfo
[i
];
2864 if (strlen (info
.strUDID
) < 1) continue;
2867 if (info
.iVendorID
!= 1002) continue;
2869 if (info
.iVendorID
!= 0x1002) continue;
2872 if (info
.iBusNumber
< 0) continue;
2873 if (info
.iDeviceNumber
< 0) continue;
2877 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2879 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2886 if (found
) continue;
2888 // add it to the list
2890 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2892 adl_adapters
[*num_adl_adapters
] = i
;
2894 // rest is just bookkeeping
2896 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2897 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2899 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2900 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2902 (*num_adl_adapters
)++;
2905 myfree (bus_numbers
);
2906 myfree (device_numbers
);
2908 // sort the list by increasing bus id, device id number
2910 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2912 return adl_adapters
;
2915 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2917 // loop through all valid devices
2919 for (int i
= 0; i
< num_adl_adapters
; i
++)
2921 u32 adapter_index
= valid_adl_device_list
[i
];
2925 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2927 // unfortunately this doesn't work since bus id and dev id are not unique
2928 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2929 // if (opencl_device_index == -1) continue;
2931 int opencl_device_index
= i
;
2933 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2935 // get fanspeed info
2937 if (hm_device
[opencl_device_index
].od_version
== 5)
2939 ADLFanSpeedInfo FanSpeedInfo
;
2941 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2943 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2945 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2947 // check read and write capability in fanspeedinfo
2949 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2950 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2952 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2956 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2959 else // od_version == 6
2961 ADLOD6FanSpeedInfo faninfo
;
2963 memset (&faninfo
, 0, sizeof (faninfo
));
2965 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2967 // check read capability in fanspeedinfo
2969 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2971 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2983 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2985 for (int i
= 0; i
< num_adl_adapters
; i
++)
2987 u32 adapter_index
= valid_adl_device_list
[i
];
2991 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2993 // get overdrive version
2995 int od_supported
= 0;
2999 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3001 // store the overdrive version in hm_device
3003 // unfortunately this doesn't work since bus id and dev id are not unique
3004 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3005 // if (opencl_device_index == -1) continue;
3007 int opencl_device_index
= i
;
3009 hm_device
[opencl_device_index
].od_version
= od_version
;
3015 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3017 for (int i
= 0; i
< num_adl_adapters
; i
++)
3019 u32 adapter_index
= valid_adl_device_list
[i
];
3023 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3025 // store the iAdapterIndex in hm_device
3027 // unfortunately this doesn't work since bus id and dev id are not unique
3028 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3029 // if (opencl_device_index == -1) continue;
3031 int opencl_device_index
= i
;
3033 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3036 return num_adl_adapters
;
3039 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3041 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3043 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3047 if (data
.hm_device
[device_id
].od_version
== 5)
3051 else if (data
.hm_device
[device_id
].od_version
== 6)
3053 int CurrentValue
= 0;
3054 int DefaultValue
= 0;
3056 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3058 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3060 return DefaultValue
;
3065 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3069 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3077 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3079 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3081 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3085 if (data
.hm_device
[device_id
].od_version
== 5)
3089 else if (data
.hm_device
[device_id
].od_version
== 6)
3096 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3100 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3108 int hm_get_temperature_with_device_id (const uint device_id
)
3110 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3112 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3116 if (data
.hm_device
[device_id
].od_version
== 5)
3118 ADLTemperature Temperature
;
3120 Temperature
.iSize
= sizeof (ADLTemperature
);
3122 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3124 return Temperature
.iTemperature
/ 1000;
3126 else if (data
.hm_device
[device_id
].od_version
== 6)
3128 int Temperature
= 0;
3130 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3132 return Temperature
/ 1000;
3137 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3139 int temperature
= 0;
3141 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3149 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3151 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3153 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3155 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3159 if (data
.hm_device
[device_id
].od_version
== 5)
3161 ADLFanSpeedValue lpFanSpeedValue
;
3163 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3165 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3166 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3168 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3170 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3172 else // od_version == 6
3179 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3194 int hm_get_fanspeed_with_device_id (const uint device_id
)
3196 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3198 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3200 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3204 if (data
.hm_device
[device_id
].od_version
== 5)
3206 ADLFanSpeedValue lpFanSpeedValue
;
3208 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3210 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3211 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3212 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3214 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3216 return lpFanSpeedValue
.iFanSpeed
;
3218 else // od_version == 6
3220 ADLOD6FanSpeedInfo faninfo
;
3222 memset (&faninfo
, 0, sizeof (faninfo
));
3224 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3226 return faninfo
.iFanSpeedPercent
;
3231 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3235 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 0, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3244 int hm_get_buslanes_with_device_id (const uint device_id
)
3246 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3248 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3252 ADLPMActivity PMActivity
;
3254 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3256 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3258 return PMActivity
.iCurrentBusLanes
;
3262 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3264 unsigned int currLinkWidth
;
3266 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3268 return currLinkWidth
;
3274 int hm_get_utilization_with_device_id (const uint device_id
)
3276 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3278 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3282 ADLPMActivity PMActivity
;
3284 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3286 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3288 return PMActivity
.iActivityPercent
;
3292 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3294 nvmlUtilization_t utilization
;
3296 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
) != NVML_SUCCESS
) return -1;
3298 return utilization
.gpu
;
3304 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3306 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3308 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3312 ADLPMActivity PMActivity
;
3314 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3316 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3318 return PMActivity
.iMemoryClock
/ 100;
3322 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3326 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3334 int hm_get_corespeed_with_device_id (const uint device_id
)
3336 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3338 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3342 ADLPMActivity PMActivity
;
3344 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3346 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3348 return PMActivity
.iEngineClock
/ 100;
3352 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3356 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3364 int hm_get_throttle_with_device_id (const uint device_id
)
3366 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3368 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3373 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3375 unsigned long long clocksThrottleReasons
= 0;
3376 unsigned long long supportedThrottleReasons
= 0;
3378 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3379 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3381 clocksThrottleReasons
&= supportedThrottleReasons
;
3383 return (clocksThrottleReasons
> 0);
3389 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3391 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3395 if (data
.hm_device
[device_id
].od_version
== 5)
3397 ADLFanSpeedValue lpFanSpeedValue
;
3399 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3401 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3402 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3403 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3404 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3406 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3410 else // od_version == 6
3412 ADLOD6FanSpeedValue fan_speed_value
;
3414 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3416 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3417 fan_speed_value
.iFanSpeed
= fanspeed
;
3419 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3429 #endif // HAVE_HWMON
3435 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3437 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3439 if (css_cnt
> SP_PW_MAX
)
3441 log_error ("ERROR: mask length is too long");
3446 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3448 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3450 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3451 uint cs_len
= css
[css_pos
].cs_len
;
3453 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3455 uint c
= cs_buf
[cs_pos
] & 0xff;
3462 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3464 cs_t
*cs
= &css
[css_cnt
];
3466 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3468 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3472 for (i
= 0; i
< cs
->cs_len
; i
++)
3474 const uint u
= cs
->cs_buf
[i
];
3479 for (i
= 0; i
< in_len
; i
++)
3481 uint u
= in_buf
[i
] & 0xff;
3483 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3485 if (css_uniq
[u
] == 1) continue;
3489 cs
->cs_buf
[cs
->cs_len
] = u
;
3497 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3501 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3503 uint p0
= in_buf
[in_pos
] & 0xff;
3505 if (interpret
== 1 && p0
== '?')
3509 if (in_pos
== in_len
) break;
3511 uint p1
= in_buf
[in_pos
] & 0xff;
3515 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3517 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3519 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3521 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3523 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3525 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3527 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3528 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3530 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3531 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3533 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3534 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3536 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3537 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3539 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3541 default: log_error ("Syntax error: %s", in_buf
);
3547 if (data
.hex_charset
)
3551 if (in_pos
== in_len
)
3553 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3558 uint p1
= in_buf
[in_pos
] & 0xff;
3560 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3562 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3569 chr
= hex_convert (p1
) << 0;
3570 chr
|= hex_convert (p0
) << 4;
3572 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3578 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3584 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3588 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3590 sum
*= css
[css_pos
].cs_len
;
3596 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3598 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3603 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3605 char p0
= mask_buf
[mask_pos
];
3611 if (mask_pos
== mask_len
) break;
3613 char p1
= mask_buf
[mask_pos
];
3619 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3621 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3623 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3625 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3627 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3629 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3631 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3632 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3634 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3635 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3637 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3638 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3640 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3641 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3643 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3645 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3651 if (data
.hex_charset
)
3655 // if there is no 2nd hex character, show an error:
3657 if (mask_pos
== mask_len
)
3659 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3664 char p1
= mask_buf
[mask_pos
];
3666 // if they are not valid hex character, show an error:
3668 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3670 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3677 chr
|= hex_convert (p1
) << 0;
3678 chr
|= hex_convert (p0
) << 4;
3680 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3686 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3693 log_error ("ERROR: invalid mask length (0)");
3703 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3705 for (int i
= 0; i
< css_cnt
; i
++)
3707 uint len
= css
[i
].cs_len
;
3708 u64 next
= val
/ len
;
3709 uint pos
= val
% len
;
3710 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3715 void mp_cut_at (char *mask
, uint max
)
3719 uint mask_len
= strlen (mask
);
3721 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3723 if (mask
[i
] == '?') i
++;
3729 void mp_setup_sys (cs_t
*mp_sys
)
3733 uint donec
[CHARSIZ
] = { 0 };
3735 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3736 mp_sys
[0].cs_buf
[pos
++] = chr
;
3737 mp_sys
[0].cs_len
= pos
; }
3739 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3740 mp_sys
[1].cs_buf
[pos
++] = chr
;
3741 mp_sys
[1].cs_len
= pos
; }
3743 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3744 mp_sys
[2].cs_buf
[pos
++] = chr
;
3745 mp_sys
[2].cs_len
= pos
; }
3747 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3748 mp_sys
[3].cs_buf
[pos
++] = chr
;
3749 mp_sys
[3].cs_len
= pos
; }
3751 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3752 mp_sys
[4].cs_len
= pos
; }
3754 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3755 mp_sys
[5].cs_len
= pos
; }
3758 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3760 FILE *fp
= fopen (buf
, "rb");
3762 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3764 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3768 char mp_file
[1024] = { 0 };
3770 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3774 len
= in_superchop (mp_file
);
3778 log_info ("WARNING: charset file corrupted");
3780 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3784 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3789 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3791 mp_usr
[index
].cs_len
= 0;
3793 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3796 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3798 char *new_mask_buf
= (char *) mymalloc (256);
3804 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3806 if (css_pos
== len
) break;
3808 char p0
= mask_buf
[mask_pos
];
3810 new_mask_buf
[mask_pos
] = p0
;
3816 if (mask_pos
== mask_len
) break;
3818 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3822 if (data
.hex_charset
)
3826 if (mask_pos
== mask_len
)
3828 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3833 char p1
= mask_buf
[mask_pos
];
3835 // if they are not valid hex character, show an error:
3837 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3839 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3844 new_mask_buf
[mask_pos
] = p1
;
3849 if (css_pos
== len
) return (new_mask_buf
);
3851 myfree (new_mask_buf
);
3860 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3866 for (i
= start
; i
< stop
; i
++)
3868 sum
*= root_css_buf
[i
].cs_len
;
3874 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3878 cs_t
*cs
= &root_css_buf
[start
];
3882 for (i
= start
; i
< stop
; i
++)
3884 const u64 m
= v
% cs
->cs_len
;
3885 const u64 d
= v
/ cs
->cs_len
;
3889 const uint k
= cs
->cs_buf
[m
];
3891 pw_buf
[i
- start
] = (char) k
;
3893 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3897 int sp_comp_val (const void *p1
, const void *p2
)
3899 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3900 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3902 return b2
->val
- b1
->val
;
3905 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
)
3912 * Initialize hcstats
3915 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3917 u64
*root_stats_ptr
= root_stats_buf
;
3919 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3921 for (i
= 0; i
< SP_PW_MAX
; i
++)
3923 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3925 root_stats_ptr
+= CHARSIZ
;
3928 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3930 u64
*markov_stats_ptr
= markov_stats_buf
;
3932 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3934 for (i
= 0; i
< SP_PW_MAX
; i
++)
3936 for (j
= 0; j
< CHARSIZ
; j
++)
3938 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3940 markov_stats_ptr
+= CHARSIZ
;
3950 char hcstat_tmp
[256] = { 0 };
3952 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3954 hcstat
= hcstat_tmp
;
3957 FILE *fd
= fopen (hcstat
, "rb");
3961 log_error ("%s: %s", hcstat
, strerror (errno
));
3966 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3968 log_error ("%s: Could not load data", hcstat
);
3975 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3977 log_error ("%s: Could not load data", hcstat
);
3987 * Markov modifier of hcstat_table on user request
3992 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3993 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3998 /* Add all stats to first position */
4000 for (i
= 1; i
< SP_PW_MAX
; i
++)
4002 u64
*out
= root_stats_buf_by_pos
[0];
4003 u64
*in
= root_stats_buf_by_pos
[i
];
4005 for (j
= 0; j
< CHARSIZ
; j
++)
4011 for (i
= 1; i
< SP_PW_MAX
; i
++)
4013 u64
*out
= markov_stats_buf_by_key
[0][0];
4014 u64
*in
= markov_stats_buf_by_key
[i
][0];
4016 for (j
= 0; j
< CHARSIZ
; j
++)
4018 for (k
= 0; k
< CHARSIZ
; k
++)
4025 /* copy them to all pw_positions */
4027 for (i
= 1; i
< SP_PW_MAX
; i
++)
4029 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4032 for (i
= 1; i
< SP_PW_MAX
; i
++)
4034 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4042 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4044 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4046 for (i
= 0; i
< SP_PW_MAX
; i
++)
4048 root_table_buf_by_pos
[i
] = root_table_ptr
;
4050 root_table_ptr
+= CHARSIZ
;
4053 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4055 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4057 for (i
= 0; i
< SP_PW_MAX
; i
++)
4059 for (j
= 0; j
< CHARSIZ
; j
++)
4061 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4063 markov_table_ptr
+= CHARSIZ
;
4068 * Convert hcstat to tables
4071 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4073 uint key
= i
% CHARSIZ
;
4075 root_table_buf
[i
].key
= key
;
4076 root_table_buf
[i
].val
= root_stats_buf
[i
];
4079 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4081 uint key
= i
% CHARSIZ
;
4083 markov_table_buf
[i
].key
= key
;
4084 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4087 myfree (root_stats_buf
);
4088 myfree (markov_stats_buf
);
4094 for (i
= 0; i
< SP_PW_MAX
; i
++)
4096 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4099 for (i
= 0; i
< SP_PW_MAX
; i
++)
4101 for (j
= 0; j
< CHARSIZ
; j
++)
4103 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4108 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
])
4111 * Convert tables to css
4114 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4116 uint pw_pos
= i
/ CHARSIZ
;
4118 cs_t
*cs
= &root_css_buf
[pw_pos
];
4120 if (cs
->cs_len
== threshold
) continue;
4122 uint key
= root_table_buf
[i
].key
;
4124 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4126 cs
->cs_buf
[cs
->cs_len
] = key
;
4132 * Convert table to css
4135 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4137 uint c
= i
/ CHARSIZ
;
4139 cs_t
*cs
= &markov_css_buf
[c
];
4141 if (cs
->cs_len
== threshold
) continue;
4143 uint pw_pos
= c
/ CHARSIZ
;
4145 uint key
= markov_table_buf
[i
].key
;
4147 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4149 cs
->cs_buf
[cs
->cs_len
] = key
;
4155 for (uint i = 0; i < 8; i++)
4157 for (uint j = 0x20; j < 0x80; j++)
4159 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4161 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4163 for (uint k = 0; k < 10; k++)
4165 printf (" %u\n", ptr->cs_buf[k]);
4172 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4174 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4176 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4186 for (uint j
= 1; j
< CHARSIZ
; j
++)
4196 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4198 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4200 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4202 out
+= CHARSIZ
* CHARSIZ
;
4203 in
+= CHARSIZ
* CHARSIZ
;
4205 for (uint j
= 0; j
< CHARSIZ
; j
++)
4212 for (uint k
= 1; k
< CHARSIZ
; k
++)
4224 * mixed shared functions
4227 void dump_hex (const u8
*s
, const int sz
)
4229 for (int i
= 0; i
< sz
; i
++)
4231 log_info_nn ("%02x ", s
[i
]);
4237 void usage_mini_print (const char *progname
)
4239 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4242 void usage_big_print (const char *progname
)
4244 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4247 char *get_exec_path ()
4249 int exec_path_len
= 1024;
4251 char *exec_path
= (char *) mymalloc (exec_path_len
);
4255 char tmp
[32] = { 0 };
4257 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4259 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4263 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4267 uint size
= exec_path_len
;
4269 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4271 log_error("! executable path buffer too small\n");
4276 const int len
= strlen (exec_path
);
4279 #error Your Operating System is not supported or detected
4287 char *get_install_dir (const char *progname
)
4289 char *install_dir
= mystrdup (progname
);
4290 char *last_slash
= NULL
;
4292 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4296 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4302 install_dir
[0] = '.';
4306 return (install_dir
);
4309 char *get_profile_dir (const char *homedir
)
4311 #define DOT_HASHCAT ".hashcat"
4313 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4315 char *profile_dir
= (char *) mymalloc (len
+ 1);
4317 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4322 char *get_session_dir (const char *profile_dir
)
4324 #define SESSIONS_FOLDER "sessions"
4326 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4328 char *session_dir
= (char *) mymalloc (len
+ 1);
4330 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4335 uint
count_lines (FILE *fd
)
4339 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4345 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4347 if (nread
< 1) continue;
4351 for (i
= 0; i
< nread
; i
++)
4353 if (prev
== '\n') cnt
++;
4364 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4368 FILE *fd
= fopen (filename
, "rb");
4372 log_error ("%s: %s", filename
, strerror (errno
));
4377 #define MAX_KEY_SIZE (1024 * 1024)
4379 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4381 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4387 for (int fpos
= 0; fpos
< nread
; fpos
++)
4389 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4391 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4392 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4393 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4394 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4396 if (kpos
>= 64) kpos
= 0;
4403 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4407 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4408 if (CPU_ISSET(core
, cpu_set
)) break;
4410 thread_affinity_policy_data_t policy
= { core
};
4412 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4414 if (data
.quiet
== 0)
4416 if (rc
!= KERN_SUCCESS
)
4418 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4426 void set_cpu_affinity (char *cpu_affinity
)
4429 DWORD_PTR aff_mask
= 0;
4437 char *devices
= strdup (cpu_affinity
);
4439 char *next
= strtok (devices
, ",");
4443 uint cpu_id
= atoi (next
);
4458 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4464 aff_mask
|= 1 << (cpu_id
- 1);
4466 CPU_SET ((cpu_id
- 1), &cpuset
);
4469 } while ((next
= strtok (NULL
, ",")) != NULL
);
4475 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4476 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4478 pthread_t thread
= pthread_self ();
4479 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4483 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4485 char *element
, *end
;
4487 end
= (char *) base
+ nmemb
* size
;
4489 for (element
= (char *) base
; element
< end
; element
+= size
)
4490 if (!compar (element
, key
))
4496 int sort_by_u32 (const void *v1
, const void *v2
)
4498 const u32
*s1
= (const u32
*) v1
;
4499 const u32
*s2
= (const u32
*) v2
;
4504 int sort_by_salt (const void *v1
, const void *v2
)
4506 const salt_t
*s1
= (const salt_t
*) v1
;
4507 const salt_t
*s2
= (const salt_t
*) v2
;
4509 const int res1
= s1
->salt_len
- s2
->salt_len
;
4511 if (res1
!= 0) return (res1
);
4513 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4515 if (res2
!= 0) return (res2
);
4523 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4524 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4531 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4532 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4538 int sort_by_salt_buf (const void *v1
, const void *v2
)
4540 const pot_t
*p1
= (const pot_t
*) v1
;
4541 const pot_t
*p2
= (const pot_t
*) v2
;
4543 const hash_t
*h1
= &p1
->hash
;
4544 const hash_t
*h2
= &p2
->hash
;
4546 const salt_t
*s1
= h1
->salt
;
4547 const salt_t
*s2
= h2
->salt
;
4553 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4554 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4560 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4562 const hash_t
*h1
= (const hash_t
*) v1
;
4563 const hash_t
*h2
= (const hash_t
*) v2
;
4565 const salt_t
*s1
= h1
->salt
;
4566 const salt_t
*s2
= h2
->salt
;
4568 // testphase: this should work
4573 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4574 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4577 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4578 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4579 if (s1->salt_len > s2->salt_len) return ( 1);
4580 if (s1->salt_len < s2->salt_len) return (-1);
4582 uint n = s1->salt_len;
4586 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4587 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4594 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4596 const hash_t
*h1
= (const hash_t
*) v1
;
4597 const hash_t
*h2
= (const hash_t
*) v2
;
4599 const salt_t
*s1
= h1
->salt
;
4600 const salt_t
*s2
= h2
->salt
;
4602 // 16 - 2 (since last 2 uints contain the digest)
4607 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4608 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4614 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4616 const hash_t
*h1
= (const hash_t
*) v1
;
4617 const hash_t
*h2
= (const hash_t
*) v2
;
4619 const void *d1
= h1
->digest
;
4620 const void *d2
= h2
->digest
;
4622 return data
.sort_by_digest (d1
, d2
);
4625 int sort_by_hash (const void *v1
, const void *v2
)
4627 const hash_t
*h1
= (const hash_t
*) v1
;
4628 const hash_t
*h2
= (const hash_t
*) v2
;
4632 const salt_t
*s1
= h1
->salt
;
4633 const salt_t
*s2
= h2
->salt
;
4635 int res
= sort_by_salt (s1
, s2
);
4637 if (res
!= 0) return (res
);
4640 const void *d1
= h1
->digest
;
4641 const void *d2
= h2
->digest
;
4643 return data
.sort_by_digest (d1
, d2
);
4646 int sort_by_pot (const void *v1
, const void *v2
)
4648 const pot_t
*p1
= (const pot_t
*) v1
;
4649 const pot_t
*p2
= (const pot_t
*) v2
;
4651 const hash_t
*h1
= &p1
->hash
;
4652 const hash_t
*h2
= &p2
->hash
;
4654 return sort_by_hash (h1
, h2
);
4657 int sort_by_mtime (const void *p1
, const void *p2
)
4659 const char **f1
= (const char **) p1
;
4660 const char **f2
= (const char **) p2
;
4662 struct stat s1
; stat (*f1
, &s1
);
4663 struct stat s2
; stat (*f2
, &s2
);
4665 return s2
.st_mtime
- s1
.st_mtime
;
4668 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4670 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4671 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4673 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4676 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4678 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4679 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4681 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4684 int sort_by_stringptr (const void *p1
, const void *p2
)
4686 const char **s1
= (const char **) p1
;
4687 const char **s2
= (const char **) p2
;
4689 return strcmp (*s1
, *s2
);
4692 int sort_by_dictstat (const void *s1
, const void *s2
)
4694 dictstat_t
*d1
= (dictstat_t
*) s1
;
4695 dictstat_t
*d2
= (dictstat_t
*) s2
;
4698 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4700 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4703 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4706 int sort_by_bitmap (const void *p1
, const void *p2
)
4708 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4709 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4711 return b1
->collisions
- b2
->collisions
;
4714 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4716 const u32
*d1
= (const u32
*) v1
;
4717 const u32
*d2
= (const u32
*) v2
;
4723 if (d1
[n
] > d2
[n
]) return ( 1);
4724 if (d1
[n
] < d2
[n
]) return (-1);
4730 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4732 const u32
*d1
= (const u32
*) v1
;
4733 const u32
*d2
= (const u32
*) v2
;
4739 if (d1
[n
] > d2
[n
]) return ( 1);
4740 if (d1
[n
] < d2
[n
]) return (-1);
4746 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4748 const u32
*d1
= (const u32
*) v1
;
4749 const u32
*d2
= (const u32
*) v2
;
4755 if (d1
[n
] > d2
[n
]) return ( 1);
4756 if (d1
[n
] < d2
[n
]) return (-1);
4762 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4764 const u32
*d1
= (const u32
*) v1
;
4765 const u32
*d2
= (const u32
*) v2
;
4771 if (d1
[n
] > d2
[n
]) return ( 1);
4772 if (d1
[n
] < d2
[n
]) return (-1);
4778 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4780 const u32
*d1
= (const u32
*) v1
;
4781 const u32
*d2
= (const u32
*) v2
;
4787 if (d1
[n
] > d2
[n
]) return ( 1);
4788 if (d1
[n
] < d2
[n
]) return (-1);
4794 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4796 const u32
*d1
= (const u32
*) v1
;
4797 const u32
*d2
= (const u32
*) v2
;
4803 if (d1
[n
] > d2
[n
]) return ( 1);
4804 if (d1
[n
] < d2
[n
]) return (-1);
4810 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4812 const u32
*d1
= (const u32
*) v1
;
4813 const u32
*d2
= (const u32
*) v2
;
4819 if (d1
[n
] > d2
[n
]) return ( 1);
4820 if (d1
[n
] < d2
[n
]) return (-1);
4826 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4828 const u32
*d1
= (const u32
*) v1
;
4829 const u32
*d2
= (const u32
*) v2
;
4835 if (d1
[n
] > d2
[n
]) return ( 1);
4836 if (d1
[n
] < d2
[n
]) return (-1);
4842 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4844 const u64
*d1
= (const u64
*) v1
;
4845 const u64
*d2
= (const u64
*) v2
;
4851 if (d1
[n
] > d2
[n
]) return ( 1);
4852 if (d1
[n
] < d2
[n
]) return (-1);
4858 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4860 const u64
*d1
= (const u64
*) v1
;
4861 const u64
*d2
= (const u64
*) v2
;
4867 if (d1
[n
] > d2
[n
]) return ( 1);
4868 if (d1
[n
] < d2
[n
]) return (-1);
4874 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4876 const u64
*d1
= (const u64
*) v1
;
4877 const u64
*d2
= (const u64
*) v2
;
4883 if (d1
[n
] > d2
[n
]) return ( 1);
4884 if (d1
[n
] < d2
[n
]) return (-1);
4890 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4892 const u32
*d1
= (const u32
*) v1
;
4893 const u32
*d2
= (const u32
*) v2
;
4895 const uint dgst_pos0
= data
.dgst_pos0
;
4896 const uint dgst_pos1
= data
.dgst_pos1
;
4897 const uint dgst_pos2
= data
.dgst_pos2
;
4898 const uint dgst_pos3
= data
.dgst_pos3
;
4900 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4901 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4902 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4903 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4904 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4905 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4906 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4907 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4912 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4914 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4915 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4917 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4919 if (res1
!= 0) return (res1
);
4924 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4926 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4927 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4929 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4931 if (res1
!= 0) return (res1
);
4933 const int res2
= t1
->attack_mode
4936 if (res2
!= 0) return (res2
);
4938 const int res3
= t1
->hash_type
4941 if (res3
!= 0) return (res3
);
4946 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
)
4948 uint outfile_autohex
= data
.outfile_autohex
;
4950 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4952 FILE *debug_fp
= NULL
;
4954 if (debug_file
!= NULL
)
4956 debug_fp
= fopen (debug_file
, "ab");
4958 lock_file (debug_fp
);
4965 if (debug_fp
== NULL
)
4967 log_info ("WARNING: Could not open debug-file for writing");
4971 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4973 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4975 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4978 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4980 if (debug_mode
== 4)
4982 fputc (':', debug_fp
);
4984 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4987 fputc ('\n', debug_fp
);
4989 if (debug_file
!= NULL
) fclose (debug_fp
);
4993 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4995 int needs_hexify
= 0;
4997 if (outfile_autohex
== 1)
4999 for (uint i
= 0; i
< plain_len
; i
++)
5001 if (plain_ptr
[i
] < 0x20)
5008 if (plain_ptr
[i
] > 0x7f)
5017 if (needs_hexify
== 1)
5019 fprintf (fp
, "$HEX[");
5021 for (uint i
= 0; i
< plain_len
; i
++)
5023 fprintf (fp
, "%02x", plain_ptr
[i
]);
5030 fwrite (plain_ptr
, plain_len
, 1, fp
);
5034 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
)
5036 uint outfile_format
= data
.outfile_format
;
5038 char separator
= data
.separator
;
5040 if (outfile_format
& OUTFILE_FMT_HASH
)
5042 fprintf (out_fp
, "%s", out_buf
);
5044 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5046 fputc (separator
, out_fp
);
5049 else if (data
.username
)
5051 if (username
!= NULL
)
5053 for (uint i
= 0; i
< user_len
; i
++)
5055 fprintf (out_fp
, "%c", username
[i
]);
5058 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5060 fputc (separator
, out_fp
);
5065 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5067 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5069 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5071 fputc (separator
, out_fp
);
5075 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5077 for (uint i
= 0; i
< plain_len
; i
++)
5079 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5082 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5084 fputc (separator
, out_fp
);
5088 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5091 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5096 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5098 fprintf (out_fp
, "%llu", crackpos
);
5103 fputc ('\n', out_fp
);
5106 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
)
5110 pot_key
.hash
.salt
= hashes_buf
->salt
;
5111 pot_key
.hash
.digest
= hashes_buf
->digest
;
5113 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5119 input_buf
[input_len
] = 0;
5122 unsigned char *username
= NULL
;
5127 user_t
*user
= hashes_buf
->hash_info
->user
;
5131 username
= (unsigned char *) (user
->user_name
);
5133 user_len
= user
->user_len
;
5137 // do output the line
5138 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5142 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5143 #define LM_MASKED_PLAIN "[notfound]"
5145 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
)
5151 pot_left_key
.hash
.salt
= hash_left
->salt
;
5152 pot_left_key
.hash
.digest
= hash_left
->digest
;
5154 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5158 uint weak_hash_found
= 0;
5160 pot_t pot_right_key
;
5162 pot_right_key
.hash
.salt
= hash_right
->salt
;
5163 pot_right_key
.hash
.digest
= hash_right
->digest
;
5165 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5167 if (pot_right_ptr
== NULL
)
5169 // special case, if "weak hash"
5171 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5173 weak_hash_found
= 1;
5175 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5177 // in theory this is not needed, but we are paranoia:
5179 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5180 pot_right_ptr
->plain_len
= 0;
5184 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5186 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
5191 // at least one half was found:
5195 input_buf
[input_len
] = 0;
5199 unsigned char *username
= NULL
;
5204 user_t
*user
= hash_left
->hash_info
->user
;
5208 username
= (unsigned char *) (user
->user_name
);
5210 user_len
= user
->user_len
;
5214 // mask the part which was not found
5216 uint left_part_masked
= 0;
5217 uint right_part_masked
= 0;
5219 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5221 if (pot_left_ptr
== NULL
)
5223 left_part_masked
= 1;
5225 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5227 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5229 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5230 pot_left_ptr
->plain_len
= mask_plain_len
;
5233 if (pot_right_ptr
== NULL
)
5235 right_part_masked
= 1;
5237 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5239 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5241 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5242 pot_right_ptr
->plain_len
= mask_plain_len
;
5245 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5249 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5251 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5253 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5255 // do output the line
5257 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5259 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5261 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5262 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5265 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
)
5269 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5271 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5273 if (pot_ptr
== NULL
)
5277 input_buf
[input_len
] = 0;
5279 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5283 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
)
5289 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5291 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5295 pot_t pot_right_key
;
5297 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5299 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5301 uint weak_hash_found
= 0;
5303 if (pot_right_ptr
== NULL
)
5305 // special case, if "weak hash"
5307 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5309 weak_hash_found
= 1;
5311 // we just need that pot_right_ptr is not a NULL pointer
5313 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5317 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5319 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5324 // ... at least one part was not cracked
5328 input_buf
[input_len
] = 0;
5330 // only show the hash part which is still not cracked
5332 uint user_len
= input_len
- 32;
5334 char *hash_output
= (char *) mymalloc (33);
5336 memcpy (hash_output
, input_buf
, input_len
);
5338 if (pot_left_ptr
!= NULL
)
5340 // only show right part (because left part was already found)
5342 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5344 hash_output
[user_len
+ 16] = 0;
5347 if (pot_right_ptr
!= NULL
)
5349 // only show left part (because right part was already found)
5351 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5353 hash_output
[user_len
+ 16] = 0;
5356 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5358 myfree (hash_output
);
5360 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5363 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5365 uint opencl_platforms_filter
= 0;
5367 if (opencl_platforms
)
5369 char *platforms
= strdup (opencl_platforms
);
5371 char *next
= strtok (platforms
, ",");
5375 int platform
= atoi (next
);
5377 if (platform
< 1 || platform
> 32)
5379 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5384 opencl_platforms_filter
|= 1 << (platform
- 1);
5386 } while ((next
= strtok (NULL
, ",")) != NULL
);
5392 opencl_platforms_filter
= -1;
5395 return opencl_platforms_filter
;
5398 u32
setup_devices_filter (char *opencl_devices
)
5400 u32 devices_filter
= 0;
5404 char *devices
= strdup (opencl_devices
);
5406 char *next
= strtok (devices
, ",");
5410 int device_id
= atoi (next
);
5412 if (device_id
< 1 || device_id
> 32)
5414 log_error ("ERROR: invalid device_id %u specified", device_id
);
5419 devices_filter
|= 1 << (device_id
- 1);
5421 } while ((next
= strtok (NULL
, ",")) != NULL
);
5427 devices_filter
= -1;
5430 return devices_filter
;
5433 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5435 cl_device_type device_types_filter
= 0;
5437 if (opencl_device_types
)
5439 char *device_types
= strdup (opencl_device_types
);
5441 char *next
= strtok (device_types
, ",");
5445 int device_type
= atoi (next
);
5447 if (device_type
< 1 || device_type
> 3)
5449 log_error ("ERROR: invalid device_type %u specified", device_type
);
5454 device_types_filter
|= 1 << device_type
;
5456 } while ((next
= strtok (NULL
, ",")) != NULL
);
5458 free (device_types
);
5462 // Do not use CPU by default, this often reduces GPU performance because
5463 // the CPU is too busy to handle GPU synchronization
5465 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5468 return device_types_filter
;
5471 u32
get_random_num (const u32 min
, const u32 max
)
5473 if (min
== max
) return (min
);
5475 return ((rand () % (max
- min
)) + min
);
5478 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5480 u32 quotient
= dividend
/ divisor
;
5482 if (dividend
% divisor
) quotient
++;
5487 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5489 u64 quotient
= dividend
/ divisor
;
5491 if (dividend
% divisor
) quotient
++;
5496 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5498 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5499 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5501 if (tm
->tm_year
- 70)
5503 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5504 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5506 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5508 else if (tm
->tm_yday
)
5510 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5511 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5513 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5515 else if (tm
->tm_hour
)
5517 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5518 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5520 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5522 else if (tm
->tm_min
)
5524 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5525 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5527 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5531 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5533 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5537 void format_speed_display (float val
, char *buf
, size_t len
)
5548 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5559 /* generate output */
5563 snprintf (buf
, len
- 1, "%.0f ", val
);
5567 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5571 void lowercase (u8
*buf
, int len
)
5573 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5576 void uppercase (u8
*buf
, int len
)
5578 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5581 int fgetl (FILE *fp
, char *line_buf
)
5587 const int c
= fgetc (fp
);
5589 if (c
== EOF
) break;
5591 line_buf
[line_len
] = (char) c
;
5595 if (line_len
== HCBUFSIZ
) line_len
--;
5597 if (c
== '\n') break;
5600 if (line_len
== 0) return 0;
5602 if (line_buf
[line_len
- 1] == '\n')
5606 line_buf
[line_len
] = 0;
5609 if (line_len
== 0) return 0;
5611 if (line_buf
[line_len
- 1] == '\r')
5615 line_buf
[line_len
] = 0;
5621 int in_superchop (char *buf
)
5623 int len
= strlen (buf
);
5627 if (buf
[len
- 1] == '\n')
5634 if (buf
[len
- 1] == '\r')
5649 char **scan_directory (const char *path
)
5651 char *tmp_path
= mystrdup (path
);
5653 size_t tmp_path_len
= strlen (tmp_path
);
5655 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5657 tmp_path
[tmp_path_len
- 1] = 0;
5659 tmp_path_len
= strlen (tmp_path
);
5662 char **files
= NULL
;
5668 if ((d
= opendir (tmp_path
)) != NULL
)
5674 memset (&e
, 0, sizeof (e
));
5675 struct dirent
*de
= NULL
;
5677 if (readdir_r (d
, &e
, &de
) != 0)
5679 log_error ("ERROR: readdir_r() failed");
5684 if (de
== NULL
) break;
5688 while ((de
= readdir (d
)) != NULL
)
5691 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5693 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5695 char *path_file
= (char *) mymalloc (path_size
+ 1);
5697 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5699 path_file
[path_size
] = 0;
5703 if ((d_test
= opendir (path_file
)) != NULL
)
5711 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5715 files
[num_files
- 1] = path_file
;
5721 else if (errno
== ENOTDIR
)
5723 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5727 files
[num_files
- 1] = mystrdup (path
);
5730 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5734 files
[num_files
- 1] = NULL
;
5741 int count_dictionaries (char **dictionary_files
)
5743 if (dictionary_files
== NULL
) return 0;
5747 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5755 char *stroptitype (const uint opti_type
)
5759 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5760 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5761 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5762 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5763 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5764 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5765 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5766 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5767 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5768 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5769 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5770 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5771 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5772 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5773 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5774 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5775 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5776 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5777 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5783 char *strparser (const uint parser_status
)
5785 switch (parser_status
)
5787 case PARSER_OK
: return ((char *) PA_000
); break;
5788 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5789 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5790 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5791 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5792 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5793 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5794 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5795 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5796 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5797 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5798 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5799 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5800 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5801 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5802 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5803 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5806 return ((char *) PA_255
);
5809 char *strhashtype (const uint hash_mode
)
5813 case 0: return ((char *) HT_00000
); break;
5814 case 10: return ((char *) HT_00010
); break;
5815 case 11: return ((char *) HT_00011
); break;
5816 case 12: return ((char *) HT_00012
); break;
5817 case 20: return ((char *) HT_00020
); break;
5818 case 21: return ((char *) HT_00021
); break;
5819 case 22: return ((char *) HT_00022
); break;
5820 case 23: return ((char *) HT_00023
); break;
5821 case 30: return ((char *) HT_00030
); break;
5822 case 40: return ((char *) HT_00040
); break;
5823 case 50: return ((char *) HT_00050
); break;
5824 case 60: return ((char *) HT_00060
); break;
5825 case 100: return ((char *) HT_00100
); break;
5826 case 101: return ((char *) HT_00101
); break;
5827 case 110: return ((char *) HT_00110
); break;
5828 case 111: return ((char *) HT_00111
); break;
5829 case 112: return ((char *) HT_00112
); break;
5830 case 120: return ((char *) HT_00120
); break;
5831 case 121: return ((char *) HT_00121
); break;
5832 case 122: return ((char *) HT_00122
); break;
5833 case 124: return ((char *) HT_00124
); break;
5834 case 125: return ((char *) HT_00125
); break;
5835 case 130: return ((char *) HT_00130
); break;
5836 case 131: return ((char *) HT_00131
); break;
5837 case 132: return ((char *) HT_00132
); break;
5838 case 133: return ((char *) HT_00133
); break;
5839 case 140: return ((char *) HT_00140
); break;
5840 case 141: return ((char *) HT_00141
); break;
5841 case 150: return ((char *) HT_00150
); break;
5842 case 160: return ((char *) HT_00160
); break;
5843 case 190: return ((char *) HT_00190
); break;
5844 case 200: return ((char *) HT_00200
); break;
5845 case 300: return ((char *) HT_00300
); break;
5846 case 400: return ((char *) HT_00400
); break;
5847 case 500: return ((char *) HT_00500
); break;
5848 case 501: return ((char *) HT_00501
); break;
5849 case 900: return ((char *) HT_00900
); break;
5850 case 910: return ((char *) HT_00910
); break;
5851 case 1000: return ((char *) HT_01000
); break;
5852 case 1100: return ((char *) HT_01100
); break;
5853 case 1400: return ((char *) HT_01400
); break;
5854 case 1410: return ((char *) HT_01410
); break;
5855 case 1420: return ((char *) HT_01420
); break;
5856 case 1421: return ((char *) HT_01421
); break;
5857 case 1430: return ((char *) HT_01430
); break;
5858 case 1440: return ((char *) HT_01440
); break;
5859 case 1441: return ((char *) HT_01441
); break;
5860 case 1450: return ((char *) HT_01450
); break;
5861 case 1460: return ((char *) HT_01460
); break;
5862 case 1500: return ((char *) HT_01500
); break;
5863 case 1600: return ((char *) HT_01600
); break;
5864 case 1700: return ((char *) HT_01700
); break;
5865 case 1710: return ((char *) HT_01710
); break;
5866 case 1711: return ((char *) HT_01711
); break;
5867 case 1720: return ((char *) HT_01720
); break;
5868 case 1722: return ((char *) HT_01722
); break;
5869 case 1730: return ((char *) HT_01730
); break;
5870 case 1731: return ((char *) HT_01731
); break;
5871 case 1740: return ((char *) HT_01740
); break;
5872 case 1750: return ((char *) HT_01750
); break;
5873 case 1760: return ((char *) HT_01760
); break;
5874 case 1800: return ((char *) HT_01800
); break;
5875 case 2100: return ((char *) HT_02100
); break;
5876 case 2400: return ((char *) HT_02400
); break;
5877 case 2410: return ((char *) HT_02410
); break;
5878 case 2500: return ((char *) HT_02500
); break;
5879 case 2600: return ((char *) HT_02600
); break;
5880 case 2611: return ((char *) HT_02611
); break;
5881 case 2612: return ((char *) HT_02612
); break;
5882 case 2711: return ((char *) HT_02711
); break;
5883 case 2811: return ((char *) HT_02811
); break;
5884 case 3000: return ((char *) HT_03000
); break;
5885 case 3100: return ((char *) HT_03100
); break;
5886 case 3200: return ((char *) HT_03200
); break;
5887 case 3710: return ((char *) HT_03710
); break;
5888 case 3711: return ((char *) HT_03711
); break;
5889 case 3800: return ((char *) HT_03800
); break;
5890 case 4300: return ((char *) HT_04300
); break;
5891 case 4400: return ((char *) HT_04400
); break;
5892 case 4500: return ((char *) HT_04500
); break;
5893 case 4700: return ((char *) HT_04700
); break;
5894 case 4800: return ((char *) HT_04800
); break;
5895 case 4900: return ((char *) HT_04900
); break;
5896 case 5000: return ((char *) HT_05000
); break;
5897 case 5100: return ((char *) HT_05100
); break;
5898 case 5200: return ((char *) HT_05200
); break;
5899 case 5300: return ((char *) HT_05300
); break;
5900 case 5400: return ((char *) HT_05400
); break;
5901 case 5500: return ((char *) HT_05500
); break;
5902 case 5600: return ((char *) HT_05600
); break;
5903 case 5700: return ((char *) HT_05700
); break;
5904 case 5800: return ((char *) HT_05800
); break;
5905 case 6000: return ((char *) HT_06000
); break;
5906 case 6100: return ((char *) HT_06100
); break;
5907 case 6211: return ((char *) HT_06211
); break;
5908 case 6212: return ((char *) HT_06212
); break;
5909 case 6213: return ((char *) HT_06213
); break;
5910 case 6221: return ((char *) HT_06221
); break;
5911 case 6222: return ((char *) HT_06222
); break;
5912 case 6223: return ((char *) HT_06223
); break;
5913 case 6231: return ((char *) HT_06231
); break;
5914 case 6232: return ((char *) HT_06232
); break;
5915 case 6233: return ((char *) HT_06233
); break;
5916 case 6241: return ((char *) HT_06241
); break;
5917 case 6242: return ((char *) HT_06242
); break;
5918 case 6243: return ((char *) HT_06243
); break;
5919 case 6300: return ((char *) HT_06300
); break;
5920 case 6400: return ((char *) HT_06400
); break;
5921 case 6500: return ((char *) HT_06500
); break;
5922 case 6600: return ((char *) HT_06600
); break;
5923 case 6700: return ((char *) HT_06700
); break;
5924 case 6800: return ((char *) HT_06800
); break;
5925 case 6900: return ((char *) HT_06900
); break;
5926 case 7100: return ((char *) HT_07100
); break;
5927 case 7200: return ((char *) HT_07200
); break;
5928 case 7300: return ((char *) HT_07300
); break;
5929 case 7400: return ((char *) HT_07400
); break;
5930 case 7500: return ((char *) HT_07500
); break;
5931 case 7600: return ((char *) HT_07600
); break;
5932 case 7700: return ((char *) HT_07700
); break;
5933 case 7800: return ((char *) HT_07800
); break;
5934 case 7900: return ((char *) HT_07900
); break;
5935 case 8000: return ((char *) HT_08000
); break;
5936 case 8100: return ((char *) HT_08100
); break;
5937 case 8200: return ((char *) HT_08200
); break;
5938 case 8300: return ((char *) HT_08300
); break;
5939 case 8400: return ((char *) HT_08400
); break;
5940 case 8500: return ((char *) HT_08500
); break;
5941 case 8600: return ((char *) HT_08600
); break;
5942 case 8700: return ((char *) HT_08700
); break;
5943 case 8800: return ((char *) HT_08800
); break;
5944 case 8900: return ((char *) HT_08900
); break;
5945 case 9000: return ((char *) HT_09000
); break;
5946 case 9100: return ((char *) HT_09100
); break;
5947 case 9200: return ((char *) HT_09200
); break;
5948 case 9300: return ((char *) HT_09300
); break;
5949 case 9400: return ((char *) HT_09400
); break;
5950 case 9500: return ((char *) HT_09500
); break;
5951 case 9600: return ((char *) HT_09600
); break;
5952 case 9700: return ((char *) HT_09700
); break;
5953 case 9710: return ((char *) HT_09710
); break;
5954 case 9720: return ((char *) HT_09720
); break;
5955 case 9800: return ((char *) HT_09800
); break;
5956 case 9810: return ((char *) HT_09810
); break;
5957 case 9820: return ((char *) HT_09820
); break;
5958 case 9900: return ((char *) HT_09900
); break;
5959 case 10000: return ((char *) HT_10000
); break;
5960 case 10100: return ((char *) HT_10100
); break;
5961 case 10200: return ((char *) HT_10200
); break;
5962 case 10300: return ((char *) HT_10300
); break;
5963 case 10400: return ((char *) HT_10400
); break;
5964 case 10410: return ((char *) HT_10410
); break;
5965 case 10420: return ((char *) HT_10420
); break;
5966 case 10500: return ((char *) HT_10500
); break;
5967 case 10600: return ((char *) HT_10600
); break;
5968 case 10700: return ((char *) HT_10700
); break;
5969 case 10800: return ((char *) HT_10800
); break;
5970 case 10900: return ((char *) HT_10900
); break;
5971 case 11000: return ((char *) HT_11000
); break;
5972 case 11100: return ((char *) HT_11100
); break;
5973 case 11200: return ((char *) HT_11200
); break;
5974 case 11300: return ((char *) HT_11300
); break;
5975 case 11400: return ((char *) HT_11400
); break;
5976 case 11500: return ((char *) HT_11500
); break;
5977 case 11600: return ((char *) HT_11600
); break;
5978 case 11700: return ((char *) HT_11700
); break;
5979 case 11800: return ((char *) HT_11800
); break;
5980 case 11900: return ((char *) HT_11900
); break;
5981 case 12000: return ((char *) HT_12000
); break;
5982 case 12100: return ((char *) HT_12100
); break;
5983 case 12200: return ((char *) HT_12200
); break;
5984 case 12300: return ((char *) HT_12300
); break;
5985 case 12400: return ((char *) HT_12400
); break;
5986 case 12500: return ((char *) HT_12500
); break;
5987 case 12600: return ((char *) HT_12600
); break;
5988 case 12700: return ((char *) HT_12700
); break;
5989 case 12800: return ((char *) HT_12800
); break;
5990 case 12900: return ((char *) HT_12900
); break;
5991 case 13000: return ((char *) HT_13000
); break;
5992 case 13100: return ((char *) HT_13100
); break;
5993 case 13200: return ((char *) HT_13200
); break;
5994 case 13300: return ((char *) HT_13300
); break;
5995 case 13400: return ((char *) HT_13400
); break;
5996 case 13500: return ((char *) HT_13500
); break;
5997 case 13600: return ((char *) HT_13600
); break;
5998 case 13711: return ((char *) HT_13711
); break;
5999 case 13712: return ((char *) HT_13712
); break;
6000 case 13713: return ((char *) HT_13713
); break;
6001 case 13721: return ((char *) HT_13721
); break;
6002 case 13722: return ((char *) HT_13722
); break;
6003 case 13723: return ((char *) HT_13723
); break;
6004 case 13731: return ((char *) HT_13731
); break;
6005 case 13732: return ((char *) HT_13732
); break;
6006 case 13733: return ((char *) HT_13733
); break;
6007 case 13741: return ((char *) HT_13741
); break;
6008 case 13742: return ((char *) HT_13742
); break;
6009 case 13743: return ((char *) HT_13743
); break;
6010 case 13751: return ((char *) HT_13751
); break;
6011 case 13752: return ((char *) HT_13752
); break;
6012 case 13753: return ((char *) HT_13753
); break;
6013 case 13761: return ((char *) HT_13761
); break;
6014 case 13762: return ((char *) HT_13762
); break;
6015 case 13763: return ((char *) HT_13763
); break;
6018 return ((char *) "Unknown");
6021 char *strstatus (const uint devices_status
)
6023 switch (devices_status
)
6025 case STATUS_INIT
: return ((char *) ST_0000
); break;
6026 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6027 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6028 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6029 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6030 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6031 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6032 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6033 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6034 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6035 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6038 return ((char *) "Unknown");
6041 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6043 uint hash_type
= data
.hash_type
;
6044 uint hash_mode
= data
.hash_mode
;
6045 uint salt_type
= data
.salt_type
;
6046 uint opts_type
= data
.opts_type
;
6047 uint opti_type
= data
.opti_type
;
6048 uint dgst_size
= data
.dgst_size
;
6050 char *hashfile
= data
.hashfile
;
6054 uint digest_buf
[64] = { 0 };
6056 u64
*digest_buf64
= (u64
*) digest_buf
;
6058 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6060 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6062 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6068 case HASH_TYPE_DESCRYPT
:
6069 FP (digest_buf
[1], digest_buf
[0], tt
);
6072 case HASH_TYPE_DESRACF
:
6073 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6074 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6076 FP (digest_buf
[1], digest_buf
[0], tt
);
6080 FP (digest_buf
[1], digest_buf
[0], tt
);
6083 case HASH_TYPE_NETNTLM
:
6084 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6085 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6086 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6087 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6089 FP (digest_buf
[1], digest_buf
[0], tt
);
6090 FP (digest_buf
[3], digest_buf
[2], tt
);
6093 case HASH_TYPE_BSDICRYPT
:
6094 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6095 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6097 FP (digest_buf
[1], digest_buf
[0], tt
);
6102 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6107 digest_buf
[0] += MD4M_A
;
6108 digest_buf
[1] += MD4M_B
;
6109 digest_buf
[2] += MD4M_C
;
6110 digest_buf
[3] += MD4M_D
;
6114 digest_buf
[0] += MD5M_A
;
6115 digest_buf
[1] += MD5M_B
;
6116 digest_buf
[2] += MD5M_C
;
6117 digest_buf
[3] += MD5M_D
;
6120 case HASH_TYPE_SHA1
:
6121 digest_buf
[0] += SHA1M_A
;
6122 digest_buf
[1] += SHA1M_B
;
6123 digest_buf
[2] += SHA1M_C
;
6124 digest_buf
[3] += SHA1M_D
;
6125 digest_buf
[4] += SHA1M_E
;
6128 case HASH_TYPE_SHA256
:
6129 digest_buf
[0] += SHA256M_A
;
6130 digest_buf
[1] += SHA256M_B
;
6131 digest_buf
[2] += SHA256M_C
;
6132 digest_buf
[3] += SHA256M_D
;
6133 digest_buf
[4] += SHA256M_E
;
6134 digest_buf
[5] += SHA256M_F
;
6135 digest_buf
[6] += SHA256M_G
;
6136 digest_buf
[7] += SHA256M_H
;
6139 case HASH_TYPE_SHA384
:
6140 digest_buf64
[0] += SHA384M_A
;
6141 digest_buf64
[1] += SHA384M_B
;
6142 digest_buf64
[2] += SHA384M_C
;
6143 digest_buf64
[3] += SHA384M_D
;
6144 digest_buf64
[4] += SHA384M_E
;
6145 digest_buf64
[5] += SHA384M_F
;
6146 digest_buf64
[6] += 0;
6147 digest_buf64
[7] += 0;
6150 case HASH_TYPE_SHA512
:
6151 digest_buf64
[0] += SHA512M_A
;
6152 digest_buf64
[1] += SHA512M_B
;
6153 digest_buf64
[2] += SHA512M_C
;
6154 digest_buf64
[3] += SHA512M_D
;
6155 digest_buf64
[4] += SHA512M_E
;
6156 digest_buf64
[5] += SHA512M_F
;
6157 digest_buf64
[6] += SHA512M_G
;
6158 digest_buf64
[7] += SHA512M_H
;
6163 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6165 if (dgst_size
== DGST_SIZE_4_2
)
6167 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6169 else if (dgst_size
== DGST_SIZE_4_4
)
6171 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6173 else if (dgst_size
== DGST_SIZE_4_5
)
6175 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6177 else if (dgst_size
== DGST_SIZE_4_6
)
6179 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6181 else if (dgst_size
== DGST_SIZE_4_8
)
6183 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6185 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6187 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6189 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6191 else if (hash_type
== HASH_TYPE_SHA384
)
6193 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6195 else if (hash_type
== HASH_TYPE_SHA512
)
6197 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6199 else if (hash_type
== HASH_TYPE_GOST
)
6201 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6204 else if (dgst_size
== DGST_SIZE_4_64
)
6206 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6208 else if (dgst_size
== DGST_SIZE_8_25
)
6210 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6214 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6215 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6216 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6222 memset (&salt
, 0, sizeof (salt_t
));
6224 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6226 char *ptr
= (char *) salt
.salt_buf
;
6228 uint len
= salt
.salt_len
;
6230 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6236 case HASH_TYPE_NETNTLM
:
6238 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6239 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6241 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6247 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6249 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6257 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6259 uint max
= salt
.salt_len
/ 4;
6263 for (uint i
= 0; i
< max
; i
++)
6265 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6269 if (opts_type
& OPTS_TYPE_ST_HEX
)
6271 char tmp
[64] = { 0 };
6273 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6275 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6280 memcpy (ptr
, tmp
, len
);
6283 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6285 memset (ptr
+ len
, 0, memset_size
);
6287 salt
.salt_len
= len
;
6291 // some modes require special encoding
6294 uint out_buf_plain
[256] = { 0 };
6295 uint out_buf_salt
[256] = { 0 };
6297 char tmp_buf
[1024] = { 0 };
6299 char *ptr_plain
= (char *) out_buf_plain
;
6300 char *ptr_salt
= (char *) out_buf_salt
;
6302 if (hash_mode
== 22)
6304 char username
[30] = { 0 };
6306 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6308 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6310 u16
*ptr
= (u16
*) digest_buf
;
6312 tmp_buf
[ 0] = sig
[0];
6313 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6314 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6315 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6316 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6317 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6318 tmp_buf
[ 6] = sig
[1];
6319 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6320 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6321 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6322 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6323 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6324 tmp_buf
[12] = sig
[2];
6325 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6326 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6327 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6328 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6329 tmp_buf
[17] = sig
[3];
6330 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6331 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6332 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6333 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6334 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6335 tmp_buf
[23] = sig
[4];
6336 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6337 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6338 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6339 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6340 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6341 tmp_buf
[29] = sig
[5];
6343 snprintf (out_buf
, len
-1, "%s:%s",
6347 else if (hash_mode
== 23)
6349 // do not show the skyper part in output
6351 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6353 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6355 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6362 else if (hash_mode
== 101)
6364 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6366 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6367 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6368 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6369 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6370 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6372 memcpy (tmp_buf
, digest_buf
, 20);
6374 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6376 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6378 else if (hash_mode
== 111)
6380 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6382 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6383 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6384 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6385 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6386 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6388 memcpy (tmp_buf
, digest_buf
, 20);
6389 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6391 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6393 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6395 else if ((hash_mode
== 122) || (hash_mode
== 125))
6397 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6398 (char *) salt
.salt_buf
,
6405 else if (hash_mode
== 124)
6407 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6408 (char *) salt
.salt_buf
,
6415 else if (hash_mode
== 131)
6417 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6418 (char *) salt
.salt_buf
,
6426 else if (hash_mode
== 132)
6428 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6429 (char *) salt
.salt_buf
,
6436 else if (hash_mode
== 133)
6438 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6440 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6441 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6442 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6443 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6444 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6446 memcpy (tmp_buf
, digest_buf
, 20);
6448 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6450 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6452 else if (hash_mode
== 141)
6454 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6456 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6458 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6460 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6462 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6463 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6464 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6465 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6466 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6468 memcpy (tmp_buf
, digest_buf
, 20);
6470 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6474 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6476 else if (hash_mode
== 400)
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]);
6485 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6487 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6489 else if (hash_mode
== 500)
6491 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6493 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6494 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6495 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6496 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6498 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6500 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6502 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6506 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6509 else if (hash_mode
== 501)
6511 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6513 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6514 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6516 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6518 else if (hash_mode
== 1421)
6520 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6522 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6538 else if (hash_mode
== 1441)
6540 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6542 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6544 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6546 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6548 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6549 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6550 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6551 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6552 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6553 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6554 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6555 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6557 memcpy (tmp_buf
, digest_buf
, 32);
6559 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6563 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6565 else if (hash_mode
== 1500)
6567 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6568 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6569 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6570 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6571 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6573 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6575 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6577 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6578 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6580 memcpy (tmp_buf
, digest_buf
, 8);
6582 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6584 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6588 else if (hash_mode
== 1600)
6590 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6592 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6593 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6594 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6595 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6597 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6599 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6601 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6605 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6608 else if (hash_mode
== 1711)
6610 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6612 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6613 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6614 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6615 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6616 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6617 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6618 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6619 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6621 memcpy (tmp_buf
, digest_buf
, 64);
6622 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6624 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6626 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6628 else if (hash_mode
== 1722)
6630 uint
*ptr
= digest_buf
;
6632 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6633 (unsigned char *) salt
.salt_buf
,
6643 else if (hash_mode
== 1731)
6645 uint
*ptr
= digest_buf
;
6647 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6648 (unsigned char *) salt
.salt_buf
,
6658 else if (hash_mode
== 1800)
6662 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6663 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6664 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6665 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6666 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6667 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6668 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6669 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6671 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6673 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6675 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6679 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6682 else if (hash_mode
== 2100)
6686 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6688 salt
.salt_iter
+ 1);
6690 uint signature_len
= strlen (out_buf
);
6692 pos
+= signature_len
;
6693 len
-= signature_len
;
6695 char *salt_ptr
= (char *) salt
.salt_buf
;
6697 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6699 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6700 byte_swap_32 (digest_buf
[0]),
6701 byte_swap_32 (digest_buf
[1]),
6702 byte_swap_32 (digest_buf
[2]),
6703 byte_swap_32 (digest_buf
[3]));
6705 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6707 memcpy (tmp_buf
, digest_buf
, 16);
6709 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6711 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6712 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6713 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6714 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6716 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6717 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6718 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6719 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6721 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6722 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6723 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6724 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6726 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6727 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6728 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6729 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6731 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6732 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6733 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6734 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6738 else if (hash_mode
== 2500)
6740 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6742 wpa_t
*wpa
= &wpas
[salt_pos
];
6744 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6745 (char *) salt
.salt_buf
,
6759 else if (hash_mode
== 4400)
6761 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6762 byte_swap_32 (digest_buf
[0]),
6763 byte_swap_32 (digest_buf
[1]),
6764 byte_swap_32 (digest_buf
[2]),
6765 byte_swap_32 (digest_buf
[3]));
6767 else if (hash_mode
== 4700)
6769 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6770 byte_swap_32 (digest_buf
[0]),
6771 byte_swap_32 (digest_buf
[1]),
6772 byte_swap_32 (digest_buf
[2]),
6773 byte_swap_32 (digest_buf
[3]),
6774 byte_swap_32 (digest_buf
[4]));
6776 else if (hash_mode
== 4800)
6778 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6780 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6785 byte_swap_32 (salt
.salt_buf
[0]),
6786 byte_swap_32 (salt
.salt_buf
[1]),
6787 byte_swap_32 (salt
.salt_buf
[2]),
6788 byte_swap_32 (salt
.salt_buf
[3]),
6791 else if (hash_mode
== 4900)
6793 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6794 byte_swap_32 (digest_buf
[0]),
6795 byte_swap_32 (digest_buf
[1]),
6796 byte_swap_32 (digest_buf
[2]),
6797 byte_swap_32 (digest_buf
[3]),
6798 byte_swap_32 (digest_buf
[4]));
6800 else if (hash_mode
== 5100)
6802 snprintf (out_buf
, len
-1, "%08x%08x",
6806 else if (hash_mode
== 5200)
6808 snprintf (out_buf
, len
-1, "%s", hashfile
);
6810 else if (hash_mode
== 5300)
6812 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6814 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6816 int buf_len
= len
-1;
6820 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6822 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6824 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6826 snprintf (out_buf
, buf_len
, ":");
6832 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6840 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6842 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6844 if ((i
== 0) || (i
== 5))
6846 snprintf (out_buf
, buf_len
, ":");
6852 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6860 for (uint i
= 0; i
< 4; i
++)
6864 snprintf (out_buf
, buf_len
, ":");
6870 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6876 else if (hash_mode
== 5400)
6878 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6880 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6882 int buf_len
= len
-1;
6886 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6888 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6890 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6892 snprintf (out_buf
, buf_len
, ":");
6898 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6906 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6908 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6910 if ((i
== 0) || (i
== 5))
6912 snprintf (out_buf
, buf_len
, ":");
6918 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6926 for (uint i
= 0; i
< 5; i
++)
6930 snprintf (out_buf
, buf_len
, ":");
6936 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6942 else if (hash_mode
== 5500)
6944 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6946 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6948 char user_buf
[64] = { 0 };
6949 char domain_buf
[64] = { 0 };
6950 char srvchall_buf
[1024] = { 0 };
6951 char clichall_buf
[1024] = { 0 };
6953 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6955 char *ptr
= (char *) netntlm
->userdomain_buf
;
6957 user_buf
[i
] = ptr
[j
];
6960 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6962 char *ptr
= (char *) netntlm
->userdomain_buf
;
6964 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6967 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6969 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6971 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6974 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6976 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6978 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6981 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6989 byte_swap_32 (salt
.salt_buf_pc
[0]),
6990 byte_swap_32 (salt
.salt_buf_pc
[1]),
6993 else if (hash_mode
== 5600)
6995 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6997 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6999 char user_buf
[64] = { 0 };
7000 char domain_buf
[64] = { 0 };
7001 char srvchall_buf
[1024] = { 0 };
7002 char clichall_buf
[1024] = { 0 };
7004 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7006 char *ptr
= (char *) netntlm
->userdomain_buf
;
7008 user_buf
[i
] = ptr
[j
];
7011 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7013 char *ptr
= (char *) netntlm
->userdomain_buf
;
7015 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7018 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7020 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7022 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7025 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7027 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7029 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7032 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7042 else if (hash_mode
== 5700)
7044 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7046 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7047 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7048 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7049 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7050 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7051 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7052 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7053 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7055 memcpy (tmp_buf
, digest_buf
, 32);
7057 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7061 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7063 else if (hash_mode
== 5800)
7065 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7066 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7067 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7068 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7069 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7071 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7078 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7080 snprintf (out_buf
, len
-1, "%s", hashfile
);
7082 else if (hash_mode
== 6300)
7084 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7086 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7087 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7088 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7089 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7091 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7093 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7095 else if (hash_mode
== 6400)
7097 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7099 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7101 else if (hash_mode
== 6500)
7103 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7105 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7107 else if (hash_mode
== 6600)
7109 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7111 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7113 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7114 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7116 uint buf_len
= len
- 1;
7118 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7121 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7123 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7128 else if (hash_mode
== 6700)
7130 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7132 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7134 else if (hash_mode
== 6800)
7136 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7138 else if (hash_mode
== 7100)
7140 uint
*ptr
= digest_buf
;
7142 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7144 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7146 uint esalt
[8] = { 0 };
7148 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7149 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7150 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7151 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7152 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7153 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7154 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7155 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7157 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",
7158 SIGNATURE_SHA512OSX
,
7160 esalt
[ 0], esalt
[ 1],
7161 esalt
[ 2], esalt
[ 3],
7162 esalt
[ 4], esalt
[ 5],
7163 esalt
[ 6], esalt
[ 7],
7171 ptr
[15], ptr
[14]);
7173 else if (hash_mode
== 7200)
7175 uint
*ptr
= digest_buf
;
7177 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7179 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7183 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7185 len_used
= strlen (out_buf
);
7187 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7189 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7191 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7194 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",
7202 ptr
[15], ptr
[14]);
7204 else if (hash_mode
== 7300)
7206 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7208 rakp_t
*rakp
= &rakps
[salt_pos
];
7210 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7212 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7215 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7222 else if (hash_mode
== 7400)
7224 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7226 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7227 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7228 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7229 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7230 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7231 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7232 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7233 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7235 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7237 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7239 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7243 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7246 else if (hash_mode
== 7500)
7248 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7250 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7252 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7253 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7255 char data
[128] = { 0 };
7257 char *ptr_data
= data
;
7259 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7261 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7264 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7266 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7271 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7273 (char *) krb5pa
->user
,
7274 (char *) krb5pa
->realm
,
7275 (char *) krb5pa
->salt
,
7278 else if (hash_mode
== 7700)
7280 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7281 (char *) salt
.salt_buf
,
7285 else if (hash_mode
== 7800)
7287 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7288 (char *) salt
.salt_buf
,
7295 else if (hash_mode
== 7900)
7297 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7301 char *tmp
= (char *) salt
.salt_buf_pc
;
7303 ptr_plain
[42] = tmp
[0];
7309 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7311 else if (hash_mode
== 8000)
7313 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7314 (unsigned char *) salt
.salt_buf
,
7324 else if (hash_mode
== 8100)
7326 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7327 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7329 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7330 (unsigned char *) salt
.salt_buf
,
7337 else if (hash_mode
== 8200)
7339 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7341 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7343 char data_buf
[4096] = { 0 };
7345 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7347 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7350 data_buf
[cloudkey
->data_len
* 2] = 0;
7352 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7353 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7354 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7355 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7356 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7357 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7358 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7359 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7361 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7362 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7363 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7364 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7366 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7382 else if (hash_mode
== 8300)
7384 char digest_buf_c
[34] = { 0 };
7386 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7387 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7388 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7389 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7390 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7392 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7394 digest_buf_c
[32] = 0;
7398 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7400 char domain_buf_c
[33] = { 0 };
7402 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7404 for (uint i
= 0; i
< salt_pc_len
; i
++)
7406 const char next
= domain_buf_c
[i
];
7408 domain_buf_c
[i
] = '.';
7413 domain_buf_c
[salt_pc_len
] = 0;
7417 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7419 else if (hash_mode
== 8500)
7421 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7423 else if (hash_mode
== 2612)
7425 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7427 (char *) salt
.salt_buf
,
7433 else if (hash_mode
== 3711)
7435 char *salt_ptr
= (char *) salt
.salt_buf
;
7437 salt_ptr
[salt
.salt_len
- 1] = 0;
7439 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7440 SIGNATURE_MEDIAWIKI_B
,
7447 else if (hash_mode
== 8800)
7449 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7451 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7453 char tmp
[3073] = { 0 };
7455 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7457 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7462 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7463 SIGNATURE_ANDROIDFDE
,
7464 byte_swap_32 (salt
.salt_buf
[0]),
7465 byte_swap_32 (salt
.salt_buf
[1]),
7466 byte_swap_32 (salt
.salt_buf
[2]),
7467 byte_swap_32 (salt
.salt_buf
[3]),
7468 byte_swap_32 (digest_buf
[0]),
7469 byte_swap_32 (digest_buf
[1]),
7470 byte_swap_32 (digest_buf
[2]),
7471 byte_swap_32 (digest_buf
[3]),
7474 else if (hash_mode
== 8900)
7476 uint N
= salt
.scrypt_N
;
7477 uint r
= salt
.scrypt_r
;
7478 uint p
= salt
.scrypt_p
;
7480 char base64_salt
[32] = { 0 };
7482 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7484 memset (tmp_buf
, 0, 46);
7486 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7487 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7488 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7489 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7490 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7491 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7492 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7493 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7494 digest_buf
[8] = 0; // needed for base64_encode ()
7496 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7498 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7506 else if (hash_mode
== 9000)
7508 snprintf (out_buf
, len
-1, "%s", hashfile
);
7510 else if (hash_mode
== 9200)
7514 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7516 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7518 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7522 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7523 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7524 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7525 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7526 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7527 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7528 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7529 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7530 digest_buf
[8] = 0; // needed for base64_encode ()
7532 char tmp_buf
[64] = { 0 };
7534 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7535 tmp_buf
[43] = 0; // cut it here
7539 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7541 else if (hash_mode
== 9300)
7543 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7544 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7545 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7546 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7547 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7548 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7549 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7550 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7551 digest_buf
[8] = 0; // needed for base64_encode ()
7553 char tmp_buf
[64] = { 0 };
7555 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7556 tmp_buf
[43] = 0; // cut it here
7558 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7560 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7562 else if (hash_mode
== 9400)
7564 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7566 office2007_t
*office2007
= &office2007s
[salt_pos
];
7568 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7569 SIGNATURE_OFFICE2007
,
7572 office2007
->keySize
,
7578 office2007
->encryptedVerifier
[0],
7579 office2007
->encryptedVerifier
[1],
7580 office2007
->encryptedVerifier
[2],
7581 office2007
->encryptedVerifier
[3],
7582 office2007
->encryptedVerifierHash
[0],
7583 office2007
->encryptedVerifierHash
[1],
7584 office2007
->encryptedVerifierHash
[2],
7585 office2007
->encryptedVerifierHash
[3],
7586 office2007
->encryptedVerifierHash
[4]);
7588 else if (hash_mode
== 9500)
7590 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7592 office2010_t
*office2010
= &office2010s
[salt_pos
];
7594 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,
7600 office2010
->encryptedVerifier
[0],
7601 office2010
->encryptedVerifier
[1],
7602 office2010
->encryptedVerifier
[2],
7603 office2010
->encryptedVerifier
[3],
7604 office2010
->encryptedVerifierHash
[0],
7605 office2010
->encryptedVerifierHash
[1],
7606 office2010
->encryptedVerifierHash
[2],
7607 office2010
->encryptedVerifierHash
[3],
7608 office2010
->encryptedVerifierHash
[4],
7609 office2010
->encryptedVerifierHash
[5],
7610 office2010
->encryptedVerifierHash
[6],
7611 office2010
->encryptedVerifierHash
[7]);
7613 else if (hash_mode
== 9600)
7615 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7617 office2013_t
*office2013
= &office2013s
[salt_pos
];
7619 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,
7625 office2013
->encryptedVerifier
[0],
7626 office2013
->encryptedVerifier
[1],
7627 office2013
->encryptedVerifier
[2],
7628 office2013
->encryptedVerifier
[3],
7629 office2013
->encryptedVerifierHash
[0],
7630 office2013
->encryptedVerifierHash
[1],
7631 office2013
->encryptedVerifierHash
[2],
7632 office2013
->encryptedVerifierHash
[3],
7633 office2013
->encryptedVerifierHash
[4],
7634 office2013
->encryptedVerifierHash
[5],
7635 office2013
->encryptedVerifierHash
[6],
7636 office2013
->encryptedVerifierHash
[7]);
7638 else if (hash_mode
== 9700)
7640 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7642 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7644 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7645 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7646 byte_swap_32 (salt
.salt_buf
[0]),
7647 byte_swap_32 (salt
.salt_buf
[1]),
7648 byte_swap_32 (salt
.salt_buf
[2]),
7649 byte_swap_32 (salt
.salt_buf
[3]),
7650 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7651 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7652 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7653 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7654 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7655 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7656 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7657 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7659 else if (hash_mode
== 9710)
7661 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7663 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7665 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7666 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7667 byte_swap_32 (salt
.salt_buf
[0]),
7668 byte_swap_32 (salt
.salt_buf
[1]),
7669 byte_swap_32 (salt
.salt_buf
[2]),
7670 byte_swap_32 (salt
.salt_buf
[3]),
7671 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7672 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7673 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7674 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7675 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7676 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7677 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7678 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7680 else if (hash_mode
== 9720)
7682 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7684 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7686 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7688 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7689 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7690 byte_swap_32 (salt
.salt_buf
[0]),
7691 byte_swap_32 (salt
.salt_buf
[1]),
7692 byte_swap_32 (salt
.salt_buf
[2]),
7693 byte_swap_32 (salt
.salt_buf
[3]),
7694 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7695 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7696 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7697 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7698 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7699 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7700 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7701 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7708 else if (hash_mode
== 9800)
7710 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7712 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7714 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7715 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7720 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7721 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7722 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7723 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7724 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7725 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7726 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7727 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7728 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7730 else if (hash_mode
== 9810)
7732 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7734 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7736 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7737 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7742 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7743 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7744 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7745 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7746 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7747 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7748 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7749 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7750 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7752 else if (hash_mode
== 9820)
7754 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7756 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7758 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7760 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7761 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7766 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7767 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7768 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7769 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7770 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7771 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7772 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7773 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7774 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7781 else if (hash_mode
== 10000)
7785 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7787 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7789 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7793 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7794 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7795 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7796 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7797 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7798 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7799 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7800 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7801 digest_buf
[8] = 0; // needed for base64_encode ()
7803 char tmp_buf
[64] = { 0 };
7805 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7809 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7811 else if (hash_mode
== 10100)
7813 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7818 byte_swap_32 (salt
.salt_buf
[0]),
7819 byte_swap_32 (salt
.salt_buf
[1]),
7820 byte_swap_32 (salt
.salt_buf
[2]),
7821 byte_swap_32 (salt
.salt_buf
[3]));
7823 else if (hash_mode
== 10200)
7825 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7827 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7831 char challenge
[100] = { 0 };
7833 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7837 char tmp_buf
[100] = { 0 };
7839 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7840 (char *) cram_md5
->user
,
7846 char response
[100] = { 0 };
7848 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7850 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7852 else if (hash_mode
== 10300)
7854 char tmp_buf
[100] = { 0 };
7856 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7857 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7859 uint tmp_len
= 20 + salt
.salt_len
;
7863 char base64_encoded
[100] = { 0 };
7865 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7867 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7869 else if (hash_mode
== 10400)
7871 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7873 pdf_t
*pdf
= &pdfs
[salt_pos
];
7875 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",
7883 byte_swap_32 (pdf
->id_buf
[0]),
7884 byte_swap_32 (pdf
->id_buf
[1]),
7885 byte_swap_32 (pdf
->id_buf
[2]),
7886 byte_swap_32 (pdf
->id_buf
[3]),
7888 byte_swap_32 (pdf
->u_buf
[0]),
7889 byte_swap_32 (pdf
->u_buf
[1]),
7890 byte_swap_32 (pdf
->u_buf
[2]),
7891 byte_swap_32 (pdf
->u_buf
[3]),
7892 byte_swap_32 (pdf
->u_buf
[4]),
7893 byte_swap_32 (pdf
->u_buf
[5]),
7894 byte_swap_32 (pdf
->u_buf
[6]),
7895 byte_swap_32 (pdf
->u_buf
[7]),
7897 byte_swap_32 (pdf
->o_buf
[0]),
7898 byte_swap_32 (pdf
->o_buf
[1]),
7899 byte_swap_32 (pdf
->o_buf
[2]),
7900 byte_swap_32 (pdf
->o_buf
[3]),
7901 byte_swap_32 (pdf
->o_buf
[4]),
7902 byte_swap_32 (pdf
->o_buf
[5]),
7903 byte_swap_32 (pdf
->o_buf
[6]),
7904 byte_swap_32 (pdf
->o_buf
[7])
7907 else if (hash_mode
== 10410)
7909 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7911 pdf_t
*pdf
= &pdfs
[salt_pos
];
7913 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",
7921 byte_swap_32 (pdf
->id_buf
[0]),
7922 byte_swap_32 (pdf
->id_buf
[1]),
7923 byte_swap_32 (pdf
->id_buf
[2]),
7924 byte_swap_32 (pdf
->id_buf
[3]),
7926 byte_swap_32 (pdf
->u_buf
[0]),
7927 byte_swap_32 (pdf
->u_buf
[1]),
7928 byte_swap_32 (pdf
->u_buf
[2]),
7929 byte_swap_32 (pdf
->u_buf
[3]),
7930 byte_swap_32 (pdf
->u_buf
[4]),
7931 byte_swap_32 (pdf
->u_buf
[5]),
7932 byte_swap_32 (pdf
->u_buf
[6]),
7933 byte_swap_32 (pdf
->u_buf
[7]),
7935 byte_swap_32 (pdf
->o_buf
[0]),
7936 byte_swap_32 (pdf
->o_buf
[1]),
7937 byte_swap_32 (pdf
->o_buf
[2]),
7938 byte_swap_32 (pdf
->o_buf
[3]),
7939 byte_swap_32 (pdf
->o_buf
[4]),
7940 byte_swap_32 (pdf
->o_buf
[5]),
7941 byte_swap_32 (pdf
->o_buf
[6]),
7942 byte_swap_32 (pdf
->o_buf
[7])
7945 else if (hash_mode
== 10420)
7947 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7949 pdf_t
*pdf
= &pdfs
[salt_pos
];
7951 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7953 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",
7961 byte_swap_32 (pdf
->id_buf
[0]),
7962 byte_swap_32 (pdf
->id_buf
[1]),
7963 byte_swap_32 (pdf
->id_buf
[2]),
7964 byte_swap_32 (pdf
->id_buf
[3]),
7966 byte_swap_32 (pdf
->u_buf
[0]),
7967 byte_swap_32 (pdf
->u_buf
[1]),
7968 byte_swap_32 (pdf
->u_buf
[2]),
7969 byte_swap_32 (pdf
->u_buf
[3]),
7970 byte_swap_32 (pdf
->u_buf
[4]),
7971 byte_swap_32 (pdf
->u_buf
[5]),
7972 byte_swap_32 (pdf
->u_buf
[6]),
7973 byte_swap_32 (pdf
->u_buf
[7]),
7975 byte_swap_32 (pdf
->o_buf
[0]),
7976 byte_swap_32 (pdf
->o_buf
[1]),
7977 byte_swap_32 (pdf
->o_buf
[2]),
7978 byte_swap_32 (pdf
->o_buf
[3]),
7979 byte_swap_32 (pdf
->o_buf
[4]),
7980 byte_swap_32 (pdf
->o_buf
[5]),
7981 byte_swap_32 (pdf
->o_buf
[6]),
7982 byte_swap_32 (pdf
->o_buf
[7]),
7990 else if (hash_mode
== 10500)
7992 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7994 pdf_t
*pdf
= &pdfs
[salt_pos
];
7996 if (pdf
->id_len
== 32)
7998 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",
8006 byte_swap_32 (pdf
->id_buf
[0]),
8007 byte_swap_32 (pdf
->id_buf
[1]),
8008 byte_swap_32 (pdf
->id_buf
[2]),
8009 byte_swap_32 (pdf
->id_buf
[3]),
8010 byte_swap_32 (pdf
->id_buf
[4]),
8011 byte_swap_32 (pdf
->id_buf
[5]),
8012 byte_swap_32 (pdf
->id_buf
[6]),
8013 byte_swap_32 (pdf
->id_buf
[7]),
8015 byte_swap_32 (pdf
->u_buf
[0]),
8016 byte_swap_32 (pdf
->u_buf
[1]),
8017 byte_swap_32 (pdf
->u_buf
[2]),
8018 byte_swap_32 (pdf
->u_buf
[3]),
8019 byte_swap_32 (pdf
->u_buf
[4]),
8020 byte_swap_32 (pdf
->u_buf
[5]),
8021 byte_swap_32 (pdf
->u_buf
[6]),
8022 byte_swap_32 (pdf
->u_buf
[7]),
8024 byte_swap_32 (pdf
->o_buf
[0]),
8025 byte_swap_32 (pdf
->o_buf
[1]),
8026 byte_swap_32 (pdf
->o_buf
[2]),
8027 byte_swap_32 (pdf
->o_buf
[3]),
8028 byte_swap_32 (pdf
->o_buf
[4]),
8029 byte_swap_32 (pdf
->o_buf
[5]),
8030 byte_swap_32 (pdf
->o_buf
[6]),
8031 byte_swap_32 (pdf
->o_buf
[7])
8036 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",
8044 byte_swap_32 (pdf
->id_buf
[0]),
8045 byte_swap_32 (pdf
->id_buf
[1]),
8046 byte_swap_32 (pdf
->id_buf
[2]),
8047 byte_swap_32 (pdf
->id_buf
[3]),
8049 byte_swap_32 (pdf
->u_buf
[0]),
8050 byte_swap_32 (pdf
->u_buf
[1]),
8051 byte_swap_32 (pdf
->u_buf
[2]),
8052 byte_swap_32 (pdf
->u_buf
[3]),
8053 byte_swap_32 (pdf
->u_buf
[4]),
8054 byte_swap_32 (pdf
->u_buf
[5]),
8055 byte_swap_32 (pdf
->u_buf
[6]),
8056 byte_swap_32 (pdf
->u_buf
[7]),
8058 byte_swap_32 (pdf
->o_buf
[0]),
8059 byte_swap_32 (pdf
->o_buf
[1]),
8060 byte_swap_32 (pdf
->o_buf
[2]),
8061 byte_swap_32 (pdf
->o_buf
[3]),
8062 byte_swap_32 (pdf
->o_buf
[4]),
8063 byte_swap_32 (pdf
->o_buf
[5]),
8064 byte_swap_32 (pdf
->o_buf
[6]),
8065 byte_swap_32 (pdf
->o_buf
[7])
8069 else if (hash_mode
== 10600)
8071 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8073 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8074 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8076 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8078 else if (hash_mode
== 10700)
8080 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8082 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8083 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8085 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8087 else if (hash_mode
== 10900)
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
== 11100)
8098 u32 salt_challenge
= salt
.salt_buf
[0];
8100 salt_challenge
= byte_swap_32 (salt_challenge
);
8102 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8104 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8105 SIGNATURE_POSTGRESQL_AUTH
,
8113 else if (hash_mode
== 11200)
8115 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8116 SIGNATURE_MYSQL_AUTH
,
8117 (unsigned char *) salt
.salt_buf
,
8124 else if (hash_mode
== 11300)
8126 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8128 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8130 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8131 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8132 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8134 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8135 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8136 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8138 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8140 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8142 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8145 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8147 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8149 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8152 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8154 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8156 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8159 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8160 SIGNATURE_BITCOIN_WALLET
,
8164 (unsigned char *) salt
.salt_buf
,
8172 free (cry_master_buf
);
8174 free (public_key_buf
);
8176 else if (hash_mode
== 11400)
8178 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8180 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8181 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8183 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8185 else if (hash_mode
== 11600)
8187 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8189 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8191 const uint data_len
= seven_zip
->data_len
;
8193 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8195 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8197 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8199 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8202 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8203 SIGNATURE_SEVEN_ZIP
,
8207 (char *) seven_zip
->salt_buf
,
8209 seven_zip
->iv_buf
[0],
8210 seven_zip
->iv_buf
[1],
8211 seven_zip
->iv_buf
[2],
8212 seven_zip
->iv_buf
[3],
8214 seven_zip
->data_len
,
8215 seven_zip
->unpack_size
,
8220 else if (hash_mode
== 11700)
8222 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8232 else if (hash_mode
== 11800)
8234 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8252 else if (hash_mode
== 11900)
8254 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8256 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8257 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8259 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8261 else if (hash_mode
== 12000)
8263 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8265 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8266 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8268 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8270 else if (hash_mode
== 12100)
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
== 12200)
8281 uint
*ptr_digest
= digest_buf
;
8282 uint
*ptr_salt
= salt
.salt_buf
;
8284 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8291 else if (hash_mode
== 12300)
8293 uint
*ptr_digest
= digest_buf
;
8294 uint
*ptr_salt
= salt
.salt_buf
;
8296 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",
8297 ptr_digest
[ 0], ptr_digest
[ 1],
8298 ptr_digest
[ 2], ptr_digest
[ 3],
8299 ptr_digest
[ 4], ptr_digest
[ 5],
8300 ptr_digest
[ 6], ptr_digest
[ 7],
8301 ptr_digest
[ 8], ptr_digest
[ 9],
8302 ptr_digest
[10], ptr_digest
[11],
8303 ptr_digest
[12], ptr_digest
[13],
8304 ptr_digest
[14], ptr_digest
[15],
8310 else if (hash_mode
== 12400)
8312 // encode iteration count
8314 char salt_iter
[5] = { 0 };
8316 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8317 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8318 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8319 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8324 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8325 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8326 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8327 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8332 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8334 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8335 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8337 memcpy (tmp_buf
, digest_buf
, 8);
8339 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8343 // fill the resulting buffer
8345 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8347 else if (hash_mode
== 12500)
8349 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8351 byte_swap_32 (salt
.salt_buf
[0]),
8352 byte_swap_32 (salt
.salt_buf
[1]),
8358 else if (hash_mode
== 12600)
8360 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8361 digest_buf
[0] + salt
.salt_buf_pc
[0],
8362 digest_buf
[1] + salt
.salt_buf_pc
[1],
8363 digest_buf
[2] + salt
.salt_buf_pc
[2],
8364 digest_buf
[3] + salt
.salt_buf_pc
[3],
8365 digest_buf
[4] + salt
.salt_buf_pc
[4],
8366 digest_buf
[5] + salt
.salt_buf_pc
[5],
8367 digest_buf
[6] + salt
.salt_buf_pc
[6],
8368 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8370 else if (hash_mode
== 12700)
8372 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8374 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8375 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8377 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8379 else if (hash_mode
== 12800)
8381 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8383 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",
8396 byte_swap_32 (digest_buf
[0]),
8397 byte_swap_32 (digest_buf
[1]),
8398 byte_swap_32 (digest_buf
[2]),
8399 byte_swap_32 (digest_buf
[3]),
8400 byte_swap_32 (digest_buf
[4]),
8401 byte_swap_32 (digest_buf
[5]),
8402 byte_swap_32 (digest_buf
[6]),
8403 byte_swap_32 (digest_buf
[7])
8406 else if (hash_mode
== 12900)
8408 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",
8417 byte_swap_32 (digest_buf
[0]),
8418 byte_swap_32 (digest_buf
[1]),
8419 byte_swap_32 (digest_buf
[2]),
8420 byte_swap_32 (digest_buf
[3]),
8421 byte_swap_32 (digest_buf
[4]),
8422 byte_swap_32 (digest_buf
[5]),
8423 byte_swap_32 (digest_buf
[6]),
8424 byte_swap_32 (digest_buf
[7]),
8431 else if (hash_mode
== 13000)
8433 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8435 rar5_t
*rar5
= &rar5s
[salt_pos
];
8437 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8447 byte_swap_32 (digest_buf
[0]),
8448 byte_swap_32 (digest_buf
[1])
8451 else if (hash_mode
== 13100)
8453 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8455 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8457 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8458 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8460 char data
[2560 * 4 * 2] = { 0 };
8462 char *ptr_data
= data
;
8464 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8465 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8470 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8471 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8473 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8475 (char *) krb5tgs
->account_info
,
8479 else if (hash_mode
== 13200)
8481 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8495 else if (hash_mode
== 13300)
8497 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8498 SIGNATURE_AXCRYPT_SHA1
,
8504 else if (hash_mode
== 13400)
8506 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8508 keepass_t
*keepass
= &keepasss
[salt_pos
];
8510 u32 version
= (u32
) keepass
->version
;
8511 u32 rounds
= salt
.salt_iter
;
8512 u32 algorithm
= (u32
) keepass
->algorithm
;
8513 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8515 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8516 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8517 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8518 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8519 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8521 /* specific to version 1 */
8525 /* specific to version 2 */
8526 u32 expected_bytes_len
;
8527 u32
*ptr_expected_bytes
;
8529 u32 final_random_seed_len
;
8530 u32 transf_random_seed_len
;
8532 u32 contents_hash_len
;
8534 transf_random_seed_len
= 8;
8536 contents_hash_len
= 8;
8537 final_random_seed_len
= 8;
8540 final_random_seed_len
= 4;
8542 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8548 char *ptr_data
= out_buf
;
8550 ptr_data
+= strlen(out_buf
);
8555 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8556 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8561 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8562 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8567 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8568 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8575 contents_len
= (u32
) keepass
->contents_len
;
8576 ptr_contents
= (u32
*) keepass
->contents
;
8578 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8579 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8591 char ptr_contents_len
[10] = { 0 };
8593 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8595 sprintf (ptr_data
, "%d", contents_len
);
8597 ptr_data
+= strlen(ptr_contents_len
);
8602 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8603 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8605 else if (version
== 2)
8607 expected_bytes_len
= 8;
8608 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8610 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8611 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8616 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8617 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8631 sprintf (ptr_data
, "%d", keyfile_len
);
8638 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8639 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8642 else if (hash_mode
== 13500)
8644 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8646 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8648 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8650 char pstoken_tmp
[1024 + 1] = { 0 };
8652 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8654 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8656 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8659 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8667 else if (hash_mode
== 13600)
8669 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8671 zip2_t
*zip2
= &zip2s
[salt_pos
];
8673 const u32 salt_len
= zip2
->salt_len
;
8675 char salt_tmp
[32 + 1] = { 0 };
8677 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8679 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8681 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8684 const u32 data_len
= zip2
->data_len
;
8686 char data_tmp
[8192 + 1] = { 0 };
8688 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8690 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8692 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8695 const u32 auth_len
= zip2
->auth_len
;
8697 char auth_tmp
[20 + 1] = { 0 };
8699 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8701 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8703 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8706 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8707 SIGNATURE_ZIP2_START
,
8713 zip2
->compress_length
,
8716 SIGNATURE_ZIP2_STOP
);
8718 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8720 snprintf (out_buf
, len
-1, "%s", hashfile
);
8724 if (hash_type
== HASH_TYPE_MD4
)
8726 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8732 else if (hash_type
== HASH_TYPE_MD5
)
8734 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8740 else if (hash_type
== HASH_TYPE_SHA1
)
8742 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8749 else if (hash_type
== HASH_TYPE_SHA256
)
8751 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8761 else if (hash_type
== HASH_TYPE_SHA384
)
8763 uint
*ptr
= digest_buf
;
8765 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8773 else if (hash_type
== HASH_TYPE_SHA512
)
8775 uint
*ptr
= digest_buf
;
8777 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8787 else if (hash_type
== HASH_TYPE_LM
)
8789 snprintf (out_buf
, len
-1, "%08x%08x",
8793 else if (hash_type
== HASH_TYPE_ORACLEH
)
8795 snprintf (out_buf
, len
-1, "%08X%08X",
8799 else if (hash_type
== HASH_TYPE_BCRYPT
)
8801 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8802 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8804 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8806 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8808 else if (hash_type
== HASH_TYPE_KECCAK
)
8810 uint
*ptr
= digest_buf
;
8812 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",
8840 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8842 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8844 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8851 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8853 digest_buf
[ 0] = digest_buf
[ 0];
8854 digest_buf
[ 1] = digest_buf
[ 1];
8855 digest_buf
[ 2] = digest_buf
[ 2];
8856 digest_buf
[ 3] = digest_buf
[ 3];
8857 digest_buf
[ 4] = digest_buf
[ 4];
8858 digest_buf
[ 5] = digest_buf
[ 5];
8859 digest_buf
[ 6] = digest_buf
[ 6];
8860 digest_buf
[ 7] = digest_buf
[ 7];
8861 digest_buf
[ 8] = digest_buf
[ 8];
8862 digest_buf
[ 9] = digest_buf
[ 9];
8863 digest_buf
[10] = digest_buf
[10];
8864 digest_buf
[11] = digest_buf
[11];
8865 digest_buf
[12] = digest_buf
[12];
8866 digest_buf
[13] = digest_buf
[13];
8867 digest_buf
[14] = digest_buf
[14];
8868 digest_buf
[15] = digest_buf
[15];
8870 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8888 else if (hash_type
== HASH_TYPE_GOST
)
8890 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8900 else if (hash_type
== HASH_TYPE_MYSQL
)
8902 snprintf (out_buf
, len
-1, "%08x%08x",
8906 else if (hash_type
== HASH_TYPE_LOTUS5
)
8908 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8914 else if (hash_type
== HASH_TYPE_LOTUS6
)
8916 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8917 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8918 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8919 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8921 char buf
[16] = { 0 };
8923 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8924 memcpy (buf
+ 5, digest_buf
, 9);
8928 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8930 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8933 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8935 else if (hash_type
== HASH_TYPE_LOTUS8
)
8937 char buf
[52] = { 0 };
8941 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8947 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8951 buf
[26] = salt
.salt_buf_pc
[0];
8952 buf
[27] = salt
.salt_buf_pc
[1];
8956 memcpy (buf
+ 28, digest_buf
, 8);
8958 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8962 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8964 else if (hash_type
== HASH_TYPE_CRC32
)
8966 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8970 if (salt_type
== SALT_TYPE_INTERN
)
8972 size_t pos
= strlen (out_buf
);
8974 out_buf
[pos
] = data
.separator
;
8976 char *ptr
= (char *) salt
.salt_buf
;
8978 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8980 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8984 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8986 memset (hccap
, 0, sizeof (hccap_t
));
8988 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8990 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8992 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8993 wpa_t
*wpa
= &wpas
[salt_pos
];
8995 hccap
->keyver
= wpa
->keyver
;
8997 hccap
->eapol_size
= wpa
->eapol_size
;
8999 if (wpa
->keyver
!= 1)
9001 uint eapol_tmp
[64] = { 0 };
9003 for (uint i
= 0; i
< 64; i
++)
9005 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9008 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9012 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9015 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9016 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9017 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9018 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9020 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9022 uint dgst_size
= data
.dgst_size
;
9024 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9026 if (wpa
->keyver
!= 1)
9028 uint digest_tmp
[4] = { 0 };
9030 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9031 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9032 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9033 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9035 memcpy (hccap
->keymic
, digest_tmp
, 16);
9039 memcpy (hccap
->keymic
, digest_ptr
, 16);
9043 void SuspendThreads ()
9045 if (data
.devices_status
== STATUS_RUNNING
)
9047 hc_timer_set (&data
.timer_paused
);
9049 data
.devices_status
= STATUS_PAUSED
;
9051 log_info ("Paused");
9055 void ResumeThreads ()
9057 if (data
.devices_status
== STATUS_PAUSED
)
9061 hc_timer_get (data
.timer_paused
, ms_paused
);
9063 data
.ms_paused
+= ms_paused
;
9065 data
.devices_status
= STATUS_RUNNING
;
9067 log_info ("Resumed");
9073 if (data
.devices_status
!= STATUS_RUNNING
) return;
9075 data
.devices_status
= STATUS_BYPASS
;
9077 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9080 void stop_at_checkpoint ()
9082 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9084 if (data
.devices_status
!= STATUS_RUNNING
) return;
9087 // this feature only makes sense if --restore-disable was not specified
9089 if (data
.restore_disable
== 1)
9091 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9096 // check if monitoring of Restore Point updates should be enabled or disabled
9098 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9100 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9102 // save the current restore point value
9104 data
.checkpoint_cur_words
= get_lowest_words_done ();
9106 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9110 data
.devices_status
= STATUS_RUNNING
;
9112 // reset the global value for checkpoint checks
9114 data
.checkpoint_cur_words
= 0;
9116 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9122 if (data
.devices_status
== STATUS_INIT
) return;
9123 if (data
.devices_status
== STATUS_STARTING
) return;
9125 data
.devices_status
= STATUS_ABORTED
;
9130 if (data
.devices_status
== STATUS_INIT
) return;
9131 if (data
.devices_status
== STATUS_STARTING
) return;
9133 data
.devices_status
= STATUS_QUIT
;
9136 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9138 FILE *fp
= fopen (kernel_file
, "rb");
9144 memset (&st
, 0, sizeof (st
));
9146 stat (kernel_file
, &st
);
9148 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9150 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9152 if (num_read
!= (size_t) st
.st_size
)
9154 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9161 buf
[st
.st_size
] = 0;
9163 for (int i
= 0; i
< num_devices
; i
++)
9165 kernel_lengths
[i
] = (size_t) st
.st_size
;
9167 kernel_sources
[i
] = buf
;
9172 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9180 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9182 if (binary_size
> 0)
9184 FILE *fp
= fopen (dst
, "wb");
9187 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9198 restore_data_t
*init_restore (int argc
, char **argv
)
9200 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9202 if (data
.restore_disable
== 0)
9204 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9208 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9212 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9221 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9223 int pidbin_len
= -1;
9226 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9228 FILE *fd
= fopen (pidbin
, "rb");
9232 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9234 pidbin
[pidbin_len
] = 0;
9238 char *argv0_r
= strrchr (argv
[0], '/');
9240 char *pidbin_r
= strrchr (pidbin
, '/');
9242 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9244 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9246 if (strcmp (argv0_r
, pidbin_r
) == 0)
9248 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9255 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9257 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9259 int pidbin2_len
= -1;
9261 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9262 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9264 pidbin
[pidbin_len
] = 0;
9265 pidbin2
[pidbin2_len
] = 0;
9269 if (strcmp (pidbin
, pidbin2
) == 0)
9271 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9284 if (rd
->version_bin
< RESTORE_MIN
)
9286 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9293 memset (rd
, 0, sizeof (restore_data_t
));
9295 rd
->version_bin
= VERSION_BIN
;
9298 rd
->pid
= getpid ();
9300 rd
->pid
= GetCurrentProcessId ();
9303 if (getcwd (rd
->cwd
, 255) == NULL
)
9316 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9318 FILE *fp
= fopen (eff_restore_file
, "rb");
9322 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9327 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9329 log_error ("ERROR: cannot read %s", eff_restore_file
);
9334 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9336 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9338 for (uint i
= 0; i
< rd
->argc
; i
++)
9340 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9342 log_error ("ERROR: cannot read %s", eff_restore_file
);
9347 size_t len
= strlen (buf
);
9349 if (len
) buf
[len
- 1] = 0;
9351 rd
->argv
[i
] = mystrdup (buf
);
9358 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9360 if (chdir (rd
->cwd
))
9362 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9363 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9364 " https://github.com/philsmd/analyze_hc_restore\n"
9365 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9371 u64
get_lowest_words_done ()
9375 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9377 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9379 if (device_param
->skipped
) continue;
9381 const u64 words_done
= device_param
->words_done
;
9383 if (words_done
< words_cur
) words_cur
= words_done
;
9386 // It's possible that a device's workload isn't finished right after a restore-case.
9387 // In that case, this function would return 0 and overwrite the real restore point
9388 // There's also data.words_cur which is set to rd->words_cur but it changes while
9389 // the attack is running therefore we should stick to rd->words_cur.
9390 // Note that -s influences rd->words_cur we should keep a close look on that.
9392 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9397 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9399 u64 words_cur
= get_lowest_words_done ();
9401 rd
->words_cur
= words_cur
;
9403 FILE *fp
= fopen (new_restore_file
, "wb");
9407 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9412 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9414 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9419 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9421 for (uint i
= 0; i
< rd
->argc
; i
++)
9423 fprintf (fp
, "%s", rd
->argv
[i
]);
9429 fsync (fileno (fp
));
9434 void cycle_restore ()
9436 const char *eff_restore_file
= data
.eff_restore_file
;
9437 const char *new_restore_file
= data
.new_restore_file
;
9439 restore_data_t
*rd
= data
.rd
;
9441 write_restore (new_restore_file
, rd
);
9445 memset (&st
, 0, sizeof(st
));
9447 if (stat (eff_restore_file
, &st
) == 0)
9449 if (unlink (eff_restore_file
))
9451 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9455 if (rename (new_restore_file
, eff_restore_file
))
9457 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9461 void check_checkpoint ()
9463 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9465 u64 words_cur
= get_lowest_words_done ();
9467 if (words_cur
!= data
.checkpoint_cur_words
)
9477 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9481 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9483 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9485 myfree (alias
->device_name
);
9486 myfree (alias
->alias_name
);
9489 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9491 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9493 myfree (entry
->device_name
);
9496 myfree (tuning_db
->alias_buf
);
9497 myfree (tuning_db
->entry_buf
);
9502 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9504 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9506 int num_lines
= count_lines (fp
);
9508 // a bit over-allocated
9510 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9511 tuning_db
->alias_cnt
= 0;
9513 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9514 tuning_db
->entry_cnt
= 0;
9519 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9521 FILE *fp
= fopen (tuning_db_file
, "rb");
9525 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9530 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9536 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9540 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9542 if (line_buf
== NULL
) break;
9546 const int line_len
= in_superchop (line_buf
);
9548 if (line_len
== 0) continue;
9550 if (line_buf
[0] == '#') continue;
9554 char *token_ptr
[7] = { NULL
};
9558 char *next
= strtok (line_buf
, "\t ");
9560 token_ptr
[token_cnt
] = next
;
9564 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9566 token_ptr
[token_cnt
] = next
;
9573 char *device_name
= token_ptr
[0];
9574 char *alias_name
= token_ptr
[1];
9576 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9578 alias
->device_name
= mystrdup (device_name
);
9579 alias
->alias_name
= mystrdup (alias_name
);
9581 tuning_db
->alias_cnt
++;
9583 else if (token_cnt
== 6)
9585 if ((token_ptr
[1][0] != '0') &&
9586 (token_ptr
[1][0] != '1') &&
9587 (token_ptr
[1][0] != '3') &&
9588 (token_ptr
[1][0] != '*'))
9590 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9595 if ((token_ptr
[3][0] != '1') &&
9596 (token_ptr
[3][0] != '2') &&
9597 (token_ptr
[3][0] != '4') &&
9598 (token_ptr
[3][0] != '8') &&
9599 (token_ptr
[3][0] != 'N'))
9601 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9606 char *device_name
= token_ptr
[0];
9608 int attack_mode
= -1;
9610 int vector_width
= -1;
9611 int kernel_accel
= -1;
9612 int kernel_loops
= -1;
9614 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9615 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9616 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9618 if (token_ptr
[4][0] != 'A')
9620 kernel_accel
= atoi (token_ptr
[4]);
9622 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9624 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9634 if (token_ptr
[5][0] != 'A')
9636 kernel_loops
= atoi (token_ptr
[5]);
9638 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9640 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9650 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9652 entry
->device_name
= mystrdup (device_name
);
9653 entry
->attack_mode
= attack_mode
;
9654 entry
->hash_type
= hash_type
;
9655 entry
->vector_width
= vector_width
;
9656 entry
->kernel_accel
= kernel_accel
;
9657 entry
->kernel_loops
= kernel_loops
;
9659 tuning_db
->entry_cnt
++;
9663 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9673 // todo: print loaded 'cnt' message
9675 // sort the database
9677 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9678 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9683 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9685 static tuning_db_entry_t s
;
9687 // first we need to convert all spaces in the device_name to underscore
9689 char *device_name_nospace
= strdup (device_param
->device_name
);
9691 int device_name_length
= strlen (device_name_nospace
);
9695 for (i
= 0; i
< device_name_length
; i
++)
9697 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9700 // find out if there's an alias configured
9702 tuning_db_alias_t a
;
9704 a
.device_name
= device_name_nospace
;
9706 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
);
9708 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9710 // attack-mode 6 and 7 are attack-mode 1 basically
9712 if (attack_mode
== 6) attack_mode
= 1;
9713 if (attack_mode
== 7) attack_mode
= 1;
9715 // bsearch is not ideal but fast enough
9717 s
.device_name
= device_name_nospace
;
9718 s
.attack_mode
= attack_mode
;
9719 s
.hash_type
= hash_type
;
9721 tuning_db_entry_t
*entry
= NULL
;
9723 // this will produce all 2^3 combinations required
9725 for (i
= 0; i
< 8; i
++)
9727 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9728 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9729 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9731 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9733 if (entry
!= NULL
) break;
9735 // in non-wildcard mode do some additional checks:
9739 // in case we have an alias-name
9741 if (alias_name
!= NULL
)
9743 s
.device_name
= alias_name
;
9745 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9747 if (entry
!= NULL
) break;
9750 // or by device type
9752 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9754 s
.device_name
= "DEVICE_TYPE_CPU";
9756 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9758 s
.device_name
= "DEVICE_TYPE_GPU";
9760 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9762 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9765 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9767 if (entry
!= NULL
) break;
9771 // free converted device_name
9773 myfree (device_name_nospace
);
9782 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9784 u8 tmp
[256] = { 0 };
9786 if (salt_len
> sizeof (tmp
))
9791 memcpy (tmp
, in
, salt_len
);
9793 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9795 if ((salt_len
% 2) == 0)
9797 u32 new_salt_len
= salt_len
/ 2;
9799 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9804 tmp
[i
] = hex_convert (p1
) << 0;
9805 tmp
[i
] |= hex_convert (p0
) << 4;
9808 salt_len
= new_salt_len
;
9815 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9817 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9820 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9822 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9826 u32
*tmp_uint
= (u32
*) tmp
;
9828 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9829 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9830 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9831 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9832 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9833 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9834 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9835 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9836 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9837 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9839 salt_len
= salt_len
* 2;
9847 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9849 lowercase (tmp
, salt_len
);
9852 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9854 uppercase (tmp
, salt_len
);
9859 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9864 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9869 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9871 u32
*tmp_uint
= (uint
*) tmp
;
9877 for (u32 i
= 0; i
< max
; i
++)
9879 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9882 // Important: we may need to increase the length of memcpy since
9883 // we don't want to "loose" some swapped bytes (could happen if
9884 // they do not perfectly fit in the 4-byte blocks)
9885 // Memcpy does always copy the bytes in the BE order, but since
9886 // we swapped them, some important bytes could be in positions
9887 // we normally skip with the original len
9889 if (len
% 4) len
+= 4 - (len
% 4);
9892 memcpy (out
, tmp
, len
);
9897 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9899 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9901 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9903 u32
*digest
= (u32
*) hash_buf
->digest
;
9905 salt_t
*salt
= hash_buf
->salt
;
9907 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9909 char *iter_pos
= input_buf
+ 4;
9911 salt
->salt_iter
= 1 << atoi (iter_pos
);
9913 char *salt_pos
= strchr (iter_pos
, '$');
9915 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9921 salt
->salt_len
= salt_len
;
9923 u8 tmp_buf
[100] = { 0 };
9925 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9927 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9929 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9931 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9932 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9933 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9934 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9936 char *hash_pos
= salt_pos
+ 22;
9938 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9940 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9942 memcpy (digest
, tmp_buf
, 24);
9944 digest
[0] = byte_swap_32 (digest
[0]);
9945 digest
[1] = byte_swap_32 (digest
[1]);
9946 digest
[2] = byte_swap_32 (digest
[2]);
9947 digest
[3] = byte_swap_32 (digest
[3]);
9948 digest
[4] = byte_swap_32 (digest
[4]);
9949 digest
[5] = byte_swap_32 (digest
[5]);
9951 digest
[5] &= ~0xff; // its just 23 not 24 !
9956 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9958 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9960 u32
*digest
= (u32
*) hash_buf
->digest
;
9962 u8 tmp_buf
[100] = { 0 };
9964 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9966 memcpy (digest
, tmp_buf
, 32);
9968 digest
[0] = byte_swap_32 (digest
[0]);
9969 digest
[1] = byte_swap_32 (digest
[1]);
9970 digest
[2] = byte_swap_32 (digest
[2]);
9971 digest
[3] = byte_swap_32 (digest
[3]);
9972 digest
[4] = byte_swap_32 (digest
[4]);
9973 digest
[5] = byte_swap_32 (digest
[5]);
9974 digest
[6] = byte_swap_32 (digest
[6]);
9975 digest
[7] = byte_swap_32 (digest
[7]);
9977 digest
[0] -= SHA256M_A
;
9978 digest
[1] -= SHA256M_B
;
9979 digest
[2] -= SHA256M_C
;
9980 digest
[3] -= SHA256M_D
;
9981 digest
[4] -= SHA256M_E
;
9982 digest
[5] -= SHA256M_F
;
9983 digest
[6] -= SHA256M_G
;
9984 digest
[7] -= SHA256M_H
;
9989 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9991 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9993 u32
*digest
= (u32
*) hash_buf
->digest
;
9995 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9996 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9998 digest
[0] = byte_swap_32 (digest
[0]);
9999 digest
[1] = byte_swap_32 (digest
[1]);
10003 IP (digest
[0], digest
[1], tt
);
10005 digest
[0] = digest
[0];
10006 digest
[1] = digest
[1];
10010 return (PARSER_OK
);
10013 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10015 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10017 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10019 u32
*digest
= (u32
*) hash_buf
->digest
;
10021 salt_t
*salt
= hash_buf
->salt
;
10023 char *hash_pos
= input_buf
+ 10;
10025 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10026 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10027 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10028 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10029 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10031 digest
[0] -= SHA1M_A
;
10032 digest
[1] -= SHA1M_B
;
10033 digest
[2] -= SHA1M_C
;
10034 digest
[3] -= SHA1M_D
;
10035 digest
[4] -= SHA1M_E
;
10037 uint salt_len
= 10;
10039 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10041 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10043 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10045 salt
->salt_len
= salt_len
;
10047 return (PARSER_OK
);
10050 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10052 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10054 u32
*digest
= (u32
*) hash_buf
->digest
;
10056 salt_t
*salt
= hash_buf
->salt
;
10058 char *hash_pos
= input_buf
+ 8;
10060 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10061 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10062 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10063 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10064 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10066 digest
[0] -= SHA1M_A
;
10067 digest
[1] -= SHA1M_B
;
10068 digest
[2] -= SHA1M_C
;
10069 digest
[3] -= SHA1M_D
;
10070 digest
[4] -= SHA1M_E
;
10074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10076 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10080 salt
->salt_len
= salt_len
;
10082 return (PARSER_OK
);
10085 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10087 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10089 u64
*digest
= (u64
*) hash_buf
->digest
;
10091 salt_t
*salt
= hash_buf
->salt
;
10093 char *hash_pos
= input_buf
+ 8;
10095 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10096 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10097 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10098 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10099 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10100 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10101 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10102 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10104 digest
[0] -= SHA512M_A
;
10105 digest
[1] -= SHA512M_B
;
10106 digest
[2] -= SHA512M_C
;
10107 digest
[3] -= SHA512M_D
;
10108 digest
[4] -= SHA512M_E
;
10109 digest
[5] -= SHA512M_F
;
10110 digest
[6] -= SHA512M_G
;
10111 digest
[7] -= SHA512M_H
;
10115 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10117 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10121 salt
->salt_len
= salt_len
;
10123 return (PARSER_OK
);
10126 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10128 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10130 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10134 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10137 u32
*digest
= (u32
*) hash_buf
->digest
;
10139 salt_t
*salt
= hash_buf
->salt
;
10141 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10142 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10143 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10144 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10146 digest
[0] = byte_swap_32 (digest
[0]);
10147 digest
[1] = byte_swap_32 (digest
[1]);
10148 digest
[2] = byte_swap_32 (digest
[2]);
10149 digest
[3] = byte_swap_32 (digest
[3]);
10151 digest
[0] -= MD5M_A
;
10152 digest
[1] -= MD5M_B
;
10153 digest
[2] -= MD5M_C
;
10154 digest
[3] -= MD5M_D
;
10156 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10158 uint salt_len
= input_len
- 32 - 1;
10160 char *salt_buf
= input_buf
+ 32 + 1;
10162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10164 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10166 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10168 salt
->salt_len
= salt_len
;
10170 return (PARSER_OK
);
10173 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10175 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10177 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10181 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10186 char clean_input_buf
[32] = { 0 };
10188 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10189 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10191 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10195 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10201 clean_input_buf
[k
] = input_buf
[i
];
10209 u32
*digest
= (u32
*) hash_buf
->digest
;
10211 salt_t
*salt
= hash_buf
->salt
;
10213 u32 a
, b
, c
, d
, e
, f
;
10215 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10216 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10217 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10218 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10219 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10220 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10222 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10223 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10225 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10226 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10227 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10228 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10229 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10230 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10232 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10233 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10235 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10236 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10237 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10238 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10239 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10240 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10242 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10243 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10245 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10246 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10247 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10248 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10249 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10250 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10252 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10253 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10255 digest
[0] = byte_swap_32 (digest
[0]);
10256 digest
[1] = byte_swap_32 (digest
[1]);
10257 digest
[2] = byte_swap_32 (digest
[2]);
10258 digest
[3] = byte_swap_32 (digest
[3]);
10260 digest
[0] -= MD5M_A
;
10261 digest
[1] -= MD5M_B
;
10262 digest
[2] -= MD5M_C
;
10263 digest
[3] -= MD5M_D
;
10265 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10267 uint salt_len
= input_len
- 30 - 1;
10269 char *salt_buf
= input_buf
+ 30 + 1;
10271 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10273 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10275 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10276 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10278 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10280 salt
->salt_len
= salt_len
;
10282 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10284 salt
->salt_len
+= 22;
10286 return (PARSER_OK
);
10289 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10291 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10293 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10297 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10300 u32
*digest
= (u32
*) hash_buf
->digest
;
10302 salt_t
*salt
= hash_buf
->salt
;
10304 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10305 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10306 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10307 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10308 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10310 digest
[0] -= SHA1M_A
;
10311 digest
[1] -= SHA1M_B
;
10312 digest
[2] -= SHA1M_C
;
10313 digest
[3] -= SHA1M_D
;
10314 digest
[4] -= SHA1M_E
;
10316 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10318 uint salt_len
= input_len
- 40 - 1;
10320 char *salt_buf
= input_buf
+ 40 + 1;
10322 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10324 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10328 salt
->salt_len
= salt_len
;
10330 return (PARSER_OK
);
10333 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10335 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10337 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10341 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10344 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10346 char *iter_pos
= input_buf
+ 6;
10348 salt_t
*salt
= hash_buf
->salt
;
10350 uint iter
= atoi (iter_pos
);
10354 iter
= ROUNDS_DCC2
;
10357 salt
->salt_iter
= iter
- 1;
10359 char *salt_pos
= strchr (iter_pos
, '#');
10361 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10365 char *digest_pos
= strchr (salt_pos
, '#');
10367 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10371 uint salt_len
= digest_pos
- salt_pos
- 1;
10373 u32
*digest
= (u32
*) hash_buf
->digest
;
10375 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10376 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10377 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10378 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10380 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10382 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10384 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10386 salt
->salt_len
= salt_len
;
10388 return (PARSER_OK
);
10391 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10393 u32
*digest
= (u32
*) hash_buf
->digest
;
10395 salt_t
*salt
= hash_buf
->salt
;
10397 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10401 memcpy (&in
, input_buf
, input_len
);
10403 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10405 memcpy (digest
, in
.keymic
, 16);
10408 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10409 The phrase "Pairwise key expansion"
10410 Access Point Address (referred to as Authenticator Address AA)
10411 Supplicant Address (referred to as Supplicant Address SA)
10412 Access Point Nonce (referred to as Authenticator Anonce)
10413 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10416 uint salt_len
= strlen (in
.essid
);
10420 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10422 return (PARSER_SALT_LENGTH
);
10425 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10427 salt
->salt_len
= salt_len
;
10429 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10431 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10433 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10435 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10437 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10438 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10442 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10443 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10446 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10448 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10449 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10453 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10454 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10457 for (int i
= 0; i
< 25; i
++)
10459 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10462 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10463 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10464 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10465 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10467 wpa
->keyver
= in
.keyver
;
10469 if (wpa
->keyver
> 255)
10471 log_info ("ATTENTION!");
10472 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10473 log_info (" This could be due to a recent aircrack-ng bug.");
10474 log_info (" The key version was automatically reset to a reasonable value.");
10477 wpa
->keyver
&= 0xff;
10480 wpa
->eapol_size
= in
.eapol_size
;
10482 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10484 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10486 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10488 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10490 if (wpa
->keyver
== 1)
10496 digest
[0] = byte_swap_32 (digest
[0]);
10497 digest
[1] = byte_swap_32 (digest
[1]);
10498 digest
[2] = byte_swap_32 (digest
[2]);
10499 digest
[3] = byte_swap_32 (digest
[3]);
10501 for (int i
= 0; i
< 64; i
++)
10503 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10507 uint32_t *p0
= (uint32_t *) in
.essid
;
10511 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10512 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10514 salt
->salt_buf
[10] = c0
;
10515 salt
->salt_buf
[11] = c1
;
10517 return (PARSER_OK
);
10520 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10522 u32
*digest
= (u32
*) hash_buf
->digest
;
10524 salt_t
*salt
= hash_buf
->salt
;
10526 if (input_len
== 0)
10528 log_error ("Password Safe v2 container not specified");
10533 FILE *fp
= fopen (input_buf
, "rb");
10537 log_error ("%s: %s", input_buf
, strerror (errno
));
10544 memset (&buf
, 0, sizeof (psafe2_hdr
));
10546 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10550 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10552 salt
->salt_buf
[0] = buf
.random
[0];
10553 salt
->salt_buf
[1] = buf
.random
[1];
10555 salt
->salt_len
= 8;
10556 salt
->salt_iter
= 1000;
10558 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10559 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10560 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10561 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10562 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10564 return (PARSER_OK
);
10567 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10569 u32
*digest
= (u32
*) hash_buf
->digest
;
10571 salt_t
*salt
= hash_buf
->salt
;
10573 if (input_len
== 0)
10575 log_error (".psafe3 not specified");
10580 FILE *fp
= fopen (input_buf
, "rb");
10584 log_error ("%s: %s", input_buf
, strerror (errno
));
10591 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10595 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10597 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10599 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10601 salt
->salt_iter
= in
.iterations
+ 1;
10603 salt
->salt_buf
[0] = in
.salt_buf
[0];
10604 salt
->salt_buf
[1] = in
.salt_buf
[1];
10605 salt
->salt_buf
[2] = in
.salt_buf
[2];
10606 salt
->salt_buf
[3] = in
.salt_buf
[3];
10607 salt
->salt_buf
[4] = in
.salt_buf
[4];
10608 salt
->salt_buf
[5] = in
.salt_buf
[5];
10609 salt
->salt_buf
[6] = in
.salt_buf
[6];
10610 salt
->salt_buf
[7] = in
.salt_buf
[7];
10612 salt
->salt_len
= 32;
10614 digest
[0] = in
.hash_buf
[0];
10615 digest
[1] = in
.hash_buf
[1];
10616 digest
[2] = in
.hash_buf
[2];
10617 digest
[3] = in
.hash_buf
[3];
10618 digest
[4] = in
.hash_buf
[4];
10619 digest
[5] = in
.hash_buf
[5];
10620 digest
[6] = in
.hash_buf
[6];
10621 digest
[7] = in
.hash_buf
[7];
10623 digest
[0] = byte_swap_32 (digest
[0]);
10624 digest
[1] = byte_swap_32 (digest
[1]);
10625 digest
[2] = byte_swap_32 (digest
[2]);
10626 digest
[3] = byte_swap_32 (digest
[3]);
10627 digest
[4] = byte_swap_32 (digest
[4]);
10628 digest
[5] = byte_swap_32 (digest
[5]);
10629 digest
[6] = byte_swap_32 (digest
[6]);
10630 digest
[7] = byte_swap_32 (digest
[7]);
10632 return (PARSER_OK
);
10635 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10637 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10639 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10641 u32
*digest
= (u32
*) hash_buf
->digest
;
10643 salt_t
*salt
= hash_buf
->salt
;
10645 char *iter_pos
= input_buf
+ 3;
10647 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10649 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10651 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10653 salt
->salt_iter
= salt_iter
;
10655 char *salt_pos
= iter_pos
+ 1;
10659 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10661 salt
->salt_len
= salt_len
;
10663 char *hash_pos
= salt_pos
+ salt_len
;
10665 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10667 return (PARSER_OK
);
10670 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10672 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10674 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10676 u32
*digest
= (u32
*) hash_buf
->digest
;
10678 salt_t
*salt
= hash_buf
->salt
;
10680 char *salt_pos
= input_buf
+ 3;
10682 uint iterations_len
= 0;
10684 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10688 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10690 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10691 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10695 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10699 iterations_len
+= 8;
10703 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10706 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10708 char *hash_pos
= strchr (salt_pos
, '$');
10710 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10712 uint salt_len
= hash_pos
- salt_pos
;
10714 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10716 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10718 salt
->salt_len
= salt_len
;
10722 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10724 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10726 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10728 return (PARSER_OK
);
10731 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10733 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10735 u32
*digest
= (u32
*) hash_buf
->digest
;
10737 salt_t
*salt
= hash_buf
->salt
;
10739 char *salt_pos
= input_buf
+ 6;
10741 uint iterations_len
= 0;
10743 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10747 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10749 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10750 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10754 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10758 iterations_len
+= 8;
10762 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10765 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10767 char *hash_pos
= strchr (salt_pos
, '$');
10769 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10771 uint salt_len
= hash_pos
- salt_pos
;
10773 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10775 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10777 salt
->salt_len
= salt_len
;
10781 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10783 return (PARSER_OK
);
10786 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10788 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10790 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10792 u32
*digest
= (u32
*) hash_buf
->digest
;
10794 salt_t
*salt
= hash_buf
->salt
;
10796 char *salt_pos
= input_buf
+ 14;
10798 char *hash_pos
= strchr (salt_pos
, '*');
10800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10804 uint salt_len
= hash_pos
- salt_pos
- 1;
10806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10812 salt
->salt_len
= salt_len
;
10814 u8 tmp_buf
[100] = { 0 };
10816 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10818 memcpy (digest
, tmp_buf
, 20);
10820 digest
[0] = byte_swap_32 (digest
[0]);
10821 digest
[1] = byte_swap_32 (digest
[1]);
10822 digest
[2] = byte_swap_32 (digest
[2]);
10823 digest
[3] = byte_swap_32 (digest
[3]);
10824 digest
[4] = byte_swap_32 (digest
[4]);
10826 digest
[0] -= SHA1M_A
;
10827 digest
[1] -= SHA1M_B
;
10828 digest
[2] -= SHA1M_C
;
10829 digest
[3] -= SHA1M_D
;
10830 digest
[4] -= SHA1M_E
;
10832 return (PARSER_OK
);
10835 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10837 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10839 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10841 if (c12
& 3) return (PARSER_HASH_VALUE
);
10843 u32
*digest
= (u32
*) hash_buf
->digest
;
10845 salt_t
*salt
= hash_buf
->salt
;
10847 // for ascii_digest
10848 salt
->salt_sign
[0] = input_buf
[0];
10849 salt
->salt_sign
[1] = input_buf
[1];
10851 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10852 | itoa64_to_int (input_buf
[1]) << 6;
10854 salt
->salt_len
= 2;
10856 u8 tmp_buf
[100] = { 0 };
10858 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10860 memcpy (digest
, tmp_buf
, 8);
10864 IP (digest
[0], digest
[1], tt
);
10869 return (PARSER_OK
);
10872 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10874 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10876 u32
*digest
= (u32
*) hash_buf
->digest
;
10878 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10879 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10880 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10881 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10883 digest
[0] = byte_swap_32 (digest
[0]);
10884 digest
[1] = byte_swap_32 (digest
[1]);
10885 digest
[2] = byte_swap_32 (digest
[2]);
10886 digest
[3] = byte_swap_32 (digest
[3]);
10888 digest
[0] -= MD4M_A
;
10889 digest
[1] -= MD4M_B
;
10890 digest
[2] -= MD4M_C
;
10891 digest
[3] -= MD4M_D
;
10893 return (PARSER_OK
);
10896 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10898 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10900 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10904 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10907 u32
*digest
= (u32
*) hash_buf
->digest
;
10909 salt_t
*salt
= hash_buf
->salt
;
10911 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10912 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10913 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10914 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10916 digest
[0] = byte_swap_32 (digest
[0]);
10917 digest
[1] = byte_swap_32 (digest
[1]);
10918 digest
[2] = byte_swap_32 (digest
[2]);
10919 digest
[3] = byte_swap_32 (digest
[3]);
10921 digest
[0] -= MD4M_A
;
10922 digest
[1] -= MD4M_B
;
10923 digest
[2] -= MD4M_C
;
10924 digest
[3] -= MD4M_D
;
10926 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10928 uint salt_len
= input_len
- 32 - 1;
10930 char *salt_buf
= input_buf
+ 32 + 1;
10932 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10934 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10936 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10938 salt
->salt_len
= salt_len
;
10940 return (PARSER_OK
);
10943 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10945 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10947 u32
*digest
= (u32
*) hash_buf
->digest
;
10949 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10950 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10951 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10952 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10954 digest
[0] = byte_swap_32 (digest
[0]);
10955 digest
[1] = byte_swap_32 (digest
[1]);
10956 digest
[2] = byte_swap_32 (digest
[2]);
10957 digest
[3] = byte_swap_32 (digest
[3]);
10959 digest
[0] -= MD5M_A
;
10960 digest
[1] -= MD5M_B
;
10961 digest
[2] -= MD5M_C
;
10962 digest
[3] -= MD5M_D
;
10964 return (PARSER_OK
);
10967 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10969 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10971 u32
*digest
= (u32
*) hash_buf
->digest
;
10973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10978 digest
[0] = byte_swap_32 (digest
[0]);
10979 digest
[1] = byte_swap_32 (digest
[1]);
10981 return (PARSER_OK
);
10984 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10986 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10988 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10992 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10995 u32
*digest
= (u32
*) hash_buf
->digest
;
10997 salt_t
*salt
= hash_buf
->salt
;
10999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11004 digest
[0] = byte_swap_32 (digest
[0]);
11005 digest
[1] = byte_swap_32 (digest
[1]);
11006 digest
[2] = byte_swap_32 (digest
[2]);
11007 digest
[3] = byte_swap_32 (digest
[3]);
11009 digest
[0] -= MD5M_A
;
11010 digest
[1] -= MD5M_B
;
11011 digest
[2] -= MD5M_C
;
11012 digest
[3] -= MD5M_D
;
11014 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11016 uint salt_len
= input_len
- 32 - 1;
11018 char *salt_buf
= input_buf
+ 32 + 1;
11020 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11022 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11024 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11026 salt
->salt_len
= salt_len
;
11028 return (PARSER_OK
);
11031 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11033 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11035 u32
*digest
= (u32
*) hash_buf
->digest
;
11037 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11038 | itoa64_to_int (input_buf
[ 1]) << 6
11039 | itoa64_to_int (input_buf
[ 2]) << 12
11040 | itoa64_to_int (input_buf
[ 3]) << 18;
11041 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11042 | itoa64_to_int (input_buf
[ 5]) << 6
11043 | itoa64_to_int (input_buf
[ 6]) << 12
11044 | itoa64_to_int (input_buf
[ 7]) << 18;
11045 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11046 | itoa64_to_int (input_buf
[ 9]) << 6
11047 | itoa64_to_int (input_buf
[10]) << 12
11048 | itoa64_to_int (input_buf
[11]) << 18;
11049 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11050 | itoa64_to_int (input_buf
[13]) << 6
11051 | itoa64_to_int (input_buf
[14]) << 12
11052 | itoa64_to_int (input_buf
[15]) << 18;
11054 digest
[0] -= MD5M_A
;
11055 digest
[1] -= MD5M_B
;
11056 digest
[2] -= MD5M_C
;
11057 digest
[3] -= MD5M_D
;
11059 digest
[0] &= 0x00ffffff;
11060 digest
[1] &= 0x00ffffff;
11061 digest
[2] &= 0x00ffffff;
11062 digest
[3] &= 0x00ffffff;
11064 return (PARSER_OK
);
11067 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11069 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11071 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11075 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11078 u32
*digest
= (u32
*) hash_buf
->digest
;
11080 salt_t
*salt
= hash_buf
->salt
;
11082 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11083 | itoa64_to_int (input_buf
[ 1]) << 6
11084 | itoa64_to_int (input_buf
[ 2]) << 12
11085 | itoa64_to_int (input_buf
[ 3]) << 18;
11086 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11087 | itoa64_to_int (input_buf
[ 5]) << 6
11088 | itoa64_to_int (input_buf
[ 6]) << 12
11089 | itoa64_to_int (input_buf
[ 7]) << 18;
11090 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11091 | itoa64_to_int (input_buf
[ 9]) << 6
11092 | itoa64_to_int (input_buf
[10]) << 12
11093 | itoa64_to_int (input_buf
[11]) << 18;
11094 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11095 | itoa64_to_int (input_buf
[13]) << 6
11096 | itoa64_to_int (input_buf
[14]) << 12
11097 | itoa64_to_int (input_buf
[15]) << 18;
11099 digest
[0] -= MD5M_A
;
11100 digest
[1] -= MD5M_B
;
11101 digest
[2] -= MD5M_C
;
11102 digest
[3] -= MD5M_D
;
11104 digest
[0] &= 0x00ffffff;
11105 digest
[1] &= 0x00ffffff;
11106 digest
[2] &= 0x00ffffff;
11107 digest
[3] &= 0x00ffffff;
11109 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11111 uint salt_len
= input_len
- 16 - 1;
11113 char *salt_buf
= input_buf
+ 16 + 1;
11115 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11117 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11121 salt
->salt_len
= salt_len
;
11123 return (PARSER_OK
);
11126 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11128 key
[0] = (nthash
[0] >> 0);
11129 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11130 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11131 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11132 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11133 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11134 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11135 key
[7] = (nthash
[6] << 1);
11147 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11149 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11151 u32
*digest
= (u32
*) hash_buf
->digest
;
11153 salt_t
*salt
= hash_buf
->salt
;
11155 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11161 char *user_pos
= input_buf
;
11163 char *unused_pos
= strchr (user_pos
, ':');
11165 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11167 uint user_len
= unused_pos
- user_pos
;
11169 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11173 char *domain_pos
= strchr (unused_pos
, ':');
11175 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11177 uint unused_len
= domain_pos
- unused_pos
;
11179 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11183 char *srvchall_pos
= strchr (domain_pos
, ':');
11185 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11187 uint domain_len
= srvchall_pos
- domain_pos
;
11189 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11193 char *hash_pos
= strchr (srvchall_pos
, ':');
11195 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11197 uint srvchall_len
= hash_pos
- srvchall_pos
;
11199 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11203 char *clichall_pos
= strchr (hash_pos
, ':');
11205 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11207 uint hash_len
= clichall_pos
- hash_pos
;
11209 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11213 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11215 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11218 * store some data for later use
11221 netntlm
->user_len
= user_len
* 2;
11222 netntlm
->domain_len
= domain_len
* 2;
11223 netntlm
->srvchall_len
= srvchall_len
/ 2;
11224 netntlm
->clichall_len
= clichall_len
/ 2;
11226 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11227 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11230 * handle username and domainname
11233 for (uint i
= 0; i
< user_len
; i
++)
11235 *userdomain_ptr
++ = user_pos
[i
];
11236 *userdomain_ptr
++ = 0;
11239 for (uint i
= 0; i
< domain_len
; i
++)
11241 *userdomain_ptr
++ = domain_pos
[i
];
11242 *userdomain_ptr
++ = 0;
11246 * handle server challenge encoding
11249 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11251 const char p0
= srvchall_pos
[i
+ 0];
11252 const char p1
= srvchall_pos
[i
+ 1];
11254 *chall_ptr
++ = hex_convert (p1
) << 0
11255 | hex_convert (p0
) << 4;
11259 * handle client challenge encoding
11262 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11264 const char p0
= clichall_pos
[i
+ 0];
11265 const char p1
= clichall_pos
[i
+ 1];
11267 *chall_ptr
++ = hex_convert (p1
) << 0
11268 | hex_convert (p0
) << 4;
11275 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11277 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11279 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11281 salt
->salt_len
= salt_len
;
11283 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11284 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11285 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11286 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11288 digest
[0] = byte_swap_32 (digest
[0]);
11289 digest
[1] = byte_swap_32 (digest
[1]);
11290 digest
[2] = byte_swap_32 (digest
[2]);
11291 digest
[3] = byte_swap_32 (digest
[3]);
11293 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11295 uint digest_tmp
[2] = { 0 };
11297 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11298 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11300 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11301 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11303 /* special case 2: ESS */
11305 if (srvchall_len
== 48)
11307 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11309 uint w
[16] = { 0 };
11311 w
[ 0] = netntlm
->chall_buf
[6];
11312 w
[ 1] = netntlm
->chall_buf
[7];
11313 w
[ 2] = netntlm
->chall_buf
[0];
11314 w
[ 3] = netntlm
->chall_buf
[1];
11318 uint dgst
[4] = { 0 };
11327 salt
->salt_buf
[0] = dgst
[0];
11328 salt
->salt_buf
[1] = dgst
[1];
11332 /* precompute netntlmv1 exploit start */
11334 for (uint i
= 0; i
< 0x10000; i
++)
11336 uint key_md4
[2] = { i
, 0 };
11337 uint key_des
[2] = { 0, 0 };
11339 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11341 uint Kc
[16] = { 0 };
11342 uint Kd
[16] = { 0 };
11344 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11346 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11348 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11350 if (data3
[0] != digest_tmp
[0]) continue;
11351 if (data3
[1] != digest_tmp
[1]) continue;
11353 salt
->salt_buf
[2] = i
;
11355 salt
->salt_len
= 24;
11360 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11361 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11363 /* precompute netntlmv1 exploit stop */
11367 IP (digest
[0], digest
[1], tt
);
11368 IP (digest
[2], digest
[3], tt
);
11370 digest
[0] = rotr32 (digest
[0], 29);
11371 digest
[1] = rotr32 (digest
[1], 29);
11372 digest
[2] = rotr32 (digest
[2], 29);
11373 digest
[3] = rotr32 (digest
[3], 29);
11375 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11377 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11378 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11380 return (PARSER_OK
);
11383 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11385 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11387 u32
*digest
= (u32
*) hash_buf
->digest
;
11389 salt_t
*salt
= hash_buf
->salt
;
11391 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11397 char *user_pos
= input_buf
;
11399 char *unused_pos
= strchr (user_pos
, ':');
11401 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11403 uint user_len
= unused_pos
- user_pos
;
11405 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11409 char *domain_pos
= strchr (unused_pos
, ':');
11411 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11413 uint unused_len
= domain_pos
- unused_pos
;
11415 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11419 char *srvchall_pos
= strchr (domain_pos
, ':');
11421 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11423 uint domain_len
= srvchall_pos
- domain_pos
;
11425 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11429 char *hash_pos
= strchr (srvchall_pos
, ':');
11431 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11433 uint srvchall_len
= hash_pos
- srvchall_pos
;
11435 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11439 char *clichall_pos
= strchr (hash_pos
, ':');
11441 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11443 uint hash_len
= clichall_pos
- hash_pos
;
11445 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11449 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11451 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11453 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11456 * store some data for later use
11459 netntlm
->user_len
= user_len
* 2;
11460 netntlm
->domain_len
= domain_len
* 2;
11461 netntlm
->srvchall_len
= srvchall_len
/ 2;
11462 netntlm
->clichall_len
= clichall_len
/ 2;
11464 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11465 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11468 * handle username and domainname
11471 for (uint i
= 0; i
< user_len
; i
++)
11473 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11474 *userdomain_ptr
++ = 0;
11477 for (uint i
= 0; i
< domain_len
; i
++)
11479 *userdomain_ptr
++ = domain_pos
[i
];
11480 *userdomain_ptr
++ = 0;
11483 *userdomain_ptr
++ = 0x80;
11486 * handle server challenge encoding
11489 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11491 const char p0
= srvchall_pos
[i
+ 0];
11492 const char p1
= srvchall_pos
[i
+ 1];
11494 *chall_ptr
++ = hex_convert (p1
) << 0
11495 | hex_convert (p0
) << 4;
11499 * handle client challenge encoding
11502 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11504 const char p0
= clichall_pos
[i
+ 0];
11505 const char p1
= clichall_pos
[i
+ 1];
11507 *chall_ptr
++ = hex_convert (p1
) << 0
11508 | hex_convert (p0
) << 4;
11511 *chall_ptr
++ = 0x80;
11514 * handle hash itself
11517 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11518 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11519 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11520 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11522 digest
[0] = byte_swap_32 (digest
[0]);
11523 digest
[1] = byte_swap_32 (digest
[1]);
11524 digest
[2] = byte_swap_32 (digest
[2]);
11525 digest
[3] = byte_swap_32 (digest
[3]);
11528 * reuse challange data as salt_buf, its the buffer that is most likely unique
11531 salt
->salt_buf
[0] = 0;
11532 salt
->salt_buf
[1] = 0;
11533 salt
->salt_buf
[2] = 0;
11534 salt
->salt_buf
[3] = 0;
11535 salt
->salt_buf
[4] = 0;
11536 salt
->salt_buf
[5] = 0;
11537 salt
->salt_buf
[6] = 0;
11538 salt
->salt_buf
[7] = 0;
11542 uptr
= (uint
*) netntlm
->userdomain_buf
;
11544 for (uint i
= 0; i
< 16; i
+= 16)
11546 md5_64 (uptr
, salt
->salt_buf
);
11549 uptr
= (uint
*) netntlm
->chall_buf
;
11551 for (uint i
= 0; i
< 256; i
+= 16)
11553 md5_64 (uptr
, salt
->salt_buf
);
11556 salt
->salt_len
= 16;
11558 return (PARSER_OK
);
11561 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11563 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11565 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11569 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11572 u32
*digest
= (u32
*) hash_buf
->digest
;
11574 salt_t
*salt
= hash_buf
->salt
;
11576 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11577 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11578 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11579 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11581 digest
[0] = byte_swap_32 (digest
[0]);
11582 digest
[1] = byte_swap_32 (digest
[1]);
11583 digest
[2] = byte_swap_32 (digest
[2]);
11584 digest
[3] = byte_swap_32 (digest
[3]);
11586 digest
[0] -= MD5M_A
;
11587 digest
[1] -= MD5M_B
;
11588 digest
[2] -= MD5M_C
;
11589 digest
[3] -= MD5M_D
;
11591 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11593 uint salt_len
= input_len
- 32 - 1;
11595 char *salt_buf
= input_buf
+ 32 + 1;
11597 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11599 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11601 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11603 salt
->salt_len
= salt_len
;
11605 return (PARSER_OK
);
11608 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11610 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11612 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11616 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11619 u32
*digest
= (u32
*) hash_buf
->digest
;
11621 salt_t
*salt
= hash_buf
->salt
;
11623 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11624 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11625 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11626 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11628 digest
[0] = byte_swap_32 (digest
[0]);
11629 digest
[1] = byte_swap_32 (digest
[1]);
11630 digest
[2] = byte_swap_32 (digest
[2]);
11631 digest
[3] = byte_swap_32 (digest
[3]);
11633 digest
[0] -= MD5M_A
;
11634 digest
[1] -= MD5M_B
;
11635 digest
[2] -= MD5M_C
;
11636 digest
[3] -= MD5M_D
;
11638 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11640 uint salt_len
= input_len
- 32 - 1;
11642 char *salt_buf
= input_buf
+ 32 + 1;
11644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11646 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11648 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11650 salt
->salt_len
= salt_len
;
11652 return (PARSER_OK
);
11655 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11657 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11659 u32
*digest
= (u32
*) hash_buf
->digest
;
11661 salt_t
*salt
= hash_buf
->salt
;
11663 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11664 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11665 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11666 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11668 digest
[0] = byte_swap_32 (digest
[0]);
11669 digest
[1] = byte_swap_32 (digest
[1]);
11670 digest
[2] = byte_swap_32 (digest
[2]);
11671 digest
[3] = byte_swap_32 (digest
[3]);
11673 digest
[0] -= MD5M_A
;
11674 digest
[1] -= MD5M_B
;
11675 digest
[2] -= MD5M_C
;
11676 digest
[3] -= MD5M_D
;
11679 * This is a virtual salt. While the algorithm is basically not salted
11680 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11681 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11686 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11688 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11690 salt
->salt_len
= salt_len
;
11692 return (PARSER_OK
);
11695 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11697 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11699 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11703 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11706 u32
*digest
= (u32
*) hash_buf
->digest
;
11708 salt_t
*salt
= hash_buf
->salt
;
11710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11715 digest
[0] = byte_swap_32 (digest
[0]);
11716 digest
[1] = byte_swap_32 (digest
[1]);
11717 digest
[2] = byte_swap_32 (digest
[2]);
11718 digest
[3] = byte_swap_32 (digest
[3]);
11720 digest
[0] -= MD5M_A
;
11721 digest
[1] -= MD5M_B
;
11722 digest
[2] -= MD5M_C
;
11723 digest
[3] -= MD5M_D
;
11725 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11727 uint salt_len
= input_len
- 32 - 1;
11729 char *salt_buf
= input_buf
+ 32 + 1;
11731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11733 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11737 salt
->salt_len
= salt_len
;
11739 return (PARSER_OK
);
11742 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11744 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11746 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11750 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11753 u32
*digest
= (u32
*) hash_buf
->digest
;
11755 salt_t
*salt
= hash_buf
->salt
;
11757 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11758 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11759 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11760 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11762 digest
[0] = byte_swap_32 (digest
[0]);
11763 digest
[1] = byte_swap_32 (digest
[1]);
11764 digest
[2] = byte_swap_32 (digest
[2]);
11765 digest
[3] = byte_swap_32 (digest
[3]);
11767 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11769 uint salt_len
= input_len
- 32 - 1;
11771 char *salt_buf
= input_buf
+ 32 + 1;
11773 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11775 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11777 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11779 salt
->salt_len
= salt_len
;
11781 return (PARSER_OK
);
11784 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11786 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11788 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11792 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11795 u32
*digest
= (u32
*) hash_buf
->digest
;
11797 salt_t
*salt
= hash_buf
->salt
;
11799 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11800 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11801 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11802 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11804 digest
[0] = byte_swap_32 (digest
[0]);
11805 digest
[1] = byte_swap_32 (digest
[1]);
11806 digest
[2] = byte_swap_32 (digest
[2]);
11807 digest
[3] = byte_swap_32 (digest
[3]);
11809 digest
[0] -= MD4M_A
;
11810 digest
[1] -= MD4M_B
;
11811 digest
[2] -= MD4M_C
;
11812 digest
[3] -= MD4M_D
;
11814 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11816 uint salt_len
= input_len
- 32 - 1;
11818 char *salt_buf
= input_buf
+ 32 + 1;
11820 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11822 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11824 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11826 salt
->salt_len
= salt_len
;
11828 return (PARSER_OK
);
11831 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11833 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11835 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11839 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11842 u32
*digest
= (u32
*) hash_buf
->digest
;
11844 salt_t
*salt
= hash_buf
->salt
;
11846 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11847 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11848 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11849 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11851 digest
[0] = byte_swap_32 (digest
[0]);
11852 digest
[1] = byte_swap_32 (digest
[1]);
11853 digest
[2] = byte_swap_32 (digest
[2]);
11854 digest
[3] = byte_swap_32 (digest
[3]);
11856 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11858 uint salt_len
= input_len
- 32 - 1;
11860 char *salt_buf
= input_buf
+ 32 + 1;
11862 uint salt_pc_block
[16] = { 0 };
11864 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11866 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11868 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11870 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11872 salt_pc_block
[14] = salt_len
* 8;
11874 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11876 md5_64 (salt_pc_block
, salt_pc_digest
);
11878 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11879 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11880 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11881 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11883 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11885 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11887 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11889 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11890 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11891 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11892 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11894 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11896 return (PARSER_OK
);
11899 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11901 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11903 u32
*digest
= (u32
*) hash_buf
->digest
;
11905 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11906 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11907 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11908 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11909 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11911 digest
[0] -= SHA1M_A
;
11912 digest
[1] -= SHA1M_B
;
11913 digest
[2] -= SHA1M_C
;
11914 digest
[3] -= SHA1M_D
;
11915 digest
[4] -= SHA1M_E
;
11917 return (PARSER_OK
);
11920 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11922 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11924 u32
*digest
= (u32
*) hash_buf
->digest
;
11926 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11927 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11928 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11929 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11930 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11932 return (PARSER_OK
);
11935 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11937 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11939 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11941 u32
*digest
= (u32
*) hash_buf
->digest
;
11945 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11946 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11947 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11948 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11949 digest
[4] = 0x00000000;
11951 return (PARSER_OK
);
11954 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11956 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11958 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11962 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11965 u32
*digest
= (u32
*) hash_buf
->digest
;
11967 salt_t
*salt
= hash_buf
->salt
;
11969 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11970 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11971 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11972 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11973 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11975 digest
[0] -= SHA1M_A
;
11976 digest
[1] -= SHA1M_B
;
11977 digest
[2] -= SHA1M_C
;
11978 digest
[3] -= SHA1M_D
;
11979 digest
[4] -= SHA1M_E
;
11981 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11983 uint salt_len
= input_len
- 40 - 1;
11985 char *salt_buf
= input_buf
+ 40 + 1;
11987 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11989 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11991 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11993 salt
->salt_len
= salt_len
;
11995 return (PARSER_OK
);
11998 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12000 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12002 u32
*digest
= (u32
*) hash_buf
->digest
;
12004 salt_t
*salt
= hash_buf
->salt
;
12006 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12008 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12009 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12010 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12011 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12012 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12014 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12016 uint salt_len
= input_len
- 40 - 1;
12018 char *salt_buf
= input_buf
+ 40 + 1;
12020 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12022 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12024 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12026 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12029 pstoken
->salt_len
= salt_len
/ 2;
12031 /* some fake salt for the sorting mechanisms */
12033 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12034 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12035 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12036 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12037 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12038 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12039 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12040 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12042 salt
->salt_len
= 32;
12044 /* we need to check if we can precompute some of the data --
12045 this is possible since the scheme is badly designed */
12047 pstoken
->pc_digest
[0] = SHA1M_A
;
12048 pstoken
->pc_digest
[1] = SHA1M_B
;
12049 pstoken
->pc_digest
[2] = SHA1M_C
;
12050 pstoken
->pc_digest
[3] = SHA1M_D
;
12051 pstoken
->pc_digest
[4] = SHA1M_E
;
12053 pstoken
->pc_offset
= 0;
12055 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12059 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12060 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12061 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12062 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12063 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12064 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12065 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12066 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12067 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12068 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12069 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12070 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12071 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12072 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12073 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12074 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12076 sha1_64 (w
, pstoken
->pc_digest
);
12078 pstoken
->pc_offset
+= 16;
12081 return (PARSER_OK
);
12084 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12086 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12088 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12090 u32
*digest
= (u32
*) hash_buf
->digest
;
12092 u8 tmp_buf
[100] = { 0 };
12094 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12096 memcpy (digest
, tmp_buf
, 20);
12098 digest
[0] = byte_swap_32 (digest
[0]);
12099 digest
[1] = byte_swap_32 (digest
[1]);
12100 digest
[2] = byte_swap_32 (digest
[2]);
12101 digest
[3] = byte_swap_32 (digest
[3]);
12102 digest
[4] = byte_swap_32 (digest
[4]);
12104 digest
[0] -= SHA1M_A
;
12105 digest
[1] -= SHA1M_B
;
12106 digest
[2] -= SHA1M_C
;
12107 digest
[3] -= SHA1M_D
;
12108 digest
[4] -= SHA1M_E
;
12110 return (PARSER_OK
);
12113 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12115 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12117 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12119 u32
*digest
= (u32
*) hash_buf
->digest
;
12121 salt_t
*salt
= hash_buf
->salt
;
12123 u8 tmp_buf
[100] = { 0 };
12125 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12127 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12129 memcpy (digest
, tmp_buf
, 20);
12131 int salt_len
= tmp_len
- 20;
12133 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12135 salt
->salt_len
= salt_len
;
12137 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12139 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12141 char *ptr
= (char *) salt
->salt_buf
;
12143 ptr
[salt
->salt_len
] = 0x80;
12146 digest
[0] = byte_swap_32 (digest
[0]);
12147 digest
[1] = byte_swap_32 (digest
[1]);
12148 digest
[2] = byte_swap_32 (digest
[2]);
12149 digest
[3] = byte_swap_32 (digest
[3]);
12150 digest
[4] = byte_swap_32 (digest
[4]);
12152 digest
[0] -= SHA1M_A
;
12153 digest
[1] -= SHA1M_B
;
12154 digest
[2] -= SHA1M_C
;
12155 digest
[3] -= SHA1M_D
;
12156 digest
[4] -= SHA1M_E
;
12158 return (PARSER_OK
);
12161 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12163 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12165 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12167 u32
*digest
= (u32
*) hash_buf
->digest
;
12169 salt_t
*salt
= hash_buf
->salt
;
12171 char *salt_buf
= input_buf
+ 6;
12175 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12177 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12179 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12181 salt
->salt_len
= salt_len
;
12183 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12185 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12186 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12187 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12188 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12189 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12191 digest
[0] -= SHA1M_A
;
12192 digest
[1] -= SHA1M_B
;
12193 digest
[2] -= SHA1M_C
;
12194 digest
[3] -= SHA1M_D
;
12195 digest
[4] -= SHA1M_E
;
12197 return (PARSER_OK
);
12200 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12202 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12204 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12206 u32
*digest
= (u32
*) hash_buf
->digest
;
12208 salt_t
*salt
= hash_buf
->salt
;
12210 char *salt_buf
= input_buf
+ 6;
12214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12216 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12218 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12220 salt
->salt_len
= salt_len
;
12222 char *hash_pos
= input_buf
+ 6 + 8;
12224 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12225 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12226 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12227 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12228 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12230 digest
[0] -= SHA1M_A
;
12231 digest
[1] -= SHA1M_B
;
12232 digest
[2] -= SHA1M_C
;
12233 digest
[3] -= SHA1M_D
;
12234 digest
[4] -= SHA1M_E
;
12236 return (PARSER_OK
);
12239 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12241 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12243 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12245 u64
*digest
= (u64
*) hash_buf
->digest
;
12247 salt_t
*salt
= hash_buf
->salt
;
12249 char *salt_buf
= input_buf
+ 6;
12253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12259 salt
->salt_len
= salt_len
;
12261 char *hash_pos
= input_buf
+ 6 + 8;
12263 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12264 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12265 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12266 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12267 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12268 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12269 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12270 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12272 digest
[0] -= SHA512M_A
;
12273 digest
[1] -= SHA512M_B
;
12274 digest
[2] -= SHA512M_C
;
12275 digest
[3] -= SHA512M_D
;
12276 digest
[4] -= SHA512M_E
;
12277 digest
[5] -= SHA512M_F
;
12278 digest
[6] -= SHA512M_G
;
12279 digest
[7] -= SHA512M_H
;
12281 return (PARSER_OK
);
12284 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12286 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12288 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12292 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12295 u32
*digest
= (u32
*) hash_buf
->digest
;
12297 salt_t
*salt
= hash_buf
->salt
;
12299 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12300 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12304 digest
[0] = byte_swap_32 (digest
[0]);
12305 digest
[1] = byte_swap_32 (digest
[1]);
12307 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12309 uint salt_len
= input_len
- 16 - 1;
12311 char *salt_buf
= input_buf
+ 16 + 1;
12313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12319 salt
->salt_len
= salt_len
;
12321 return (PARSER_OK
);
12324 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12326 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12328 u32
*digest
= (u32
*) hash_buf
->digest
;
12330 salt_t
*salt
= hash_buf
->salt
;
12332 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12333 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12334 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12335 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12336 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12338 digest
[0] -= SHA1M_A
;
12339 digest
[1] -= SHA1M_B
;
12340 digest
[2] -= SHA1M_C
;
12341 digest
[3] -= SHA1M_D
;
12342 digest
[4] -= SHA1M_E
;
12344 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12346 uint salt_len
= input_len
- 40 - 1;
12348 char *salt_buf
= input_buf
+ 40 + 1;
12350 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12352 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12354 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12356 salt
->salt_len
= salt_len
;
12358 return (PARSER_OK
);
12361 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12363 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12365 u32
*digest
= (u32
*) hash_buf
->digest
;
12367 salt_t
*salt
= hash_buf
->salt
;
12369 char *hash_pos
= input_buf
;
12371 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12372 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12373 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12374 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12375 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12376 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12377 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12378 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12379 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12380 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12381 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12382 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12383 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12384 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12385 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12386 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12388 char *salt_pos
= input_buf
+ 128;
12390 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12391 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12392 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12393 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12395 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12396 salt
->salt_len
= 16;
12398 return (PARSER_OK
);
12401 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12403 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12405 u32
*digest
= (u32
*) hash_buf
->digest
;
12407 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12408 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12409 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12410 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12411 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12412 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12413 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12414 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12416 digest
[0] -= SHA256M_A
;
12417 digest
[1] -= SHA256M_B
;
12418 digest
[2] -= SHA256M_C
;
12419 digest
[3] -= SHA256M_D
;
12420 digest
[4] -= SHA256M_E
;
12421 digest
[5] -= SHA256M_F
;
12422 digest
[6] -= SHA256M_G
;
12423 digest
[7] -= SHA256M_H
;
12425 return (PARSER_OK
);
12428 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12430 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12432 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12436 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12439 u32
*digest
= (u32
*) hash_buf
->digest
;
12441 salt_t
*salt
= hash_buf
->salt
;
12443 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12444 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12445 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12446 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12447 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12448 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12449 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12450 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12452 digest
[0] -= SHA256M_A
;
12453 digest
[1] -= SHA256M_B
;
12454 digest
[2] -= SHA256M_C
;
12455 digest
[3] -= SHA256M_D
;
12456 digest
[4] -= SHA256M_E
;
12457 digest
[5] -= SHA256M_F
;
12458 digest
[6] -= SHA256M_G
;
12459 digest
[7] -= SHA256M_H
;
12461 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12463 uint salt_len
= input_len
- 64 - 1;
12465 char *salt_buf
= input_buf
+ 64 + 1;
12467 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12469 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12471 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12473 salt
->salt_len
= salt_len
;
12475 return (PARSER_OK
);
12478 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12480 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12482 u64
*digest
= (u64
*) hash_buf
->digest
;
12484 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12485 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12486 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12487 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12488 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12489 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12493 digest
[0] -= SHA384M_A
;
12494 digest
[1] -= SHA384M_B
;
12495 digest
[2] -= SHA384M_C
;
12496 digest
[3] -= SHA384M_D
;
12497 digest
[4] -= SHA384M_E
;
12498 digest
[5] -= SHA384M_F
;
12502 return (PARSER_OK
);
12505 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12507 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12509 u64
*digest
= (u64
*) hash_buf
->digest
;
12511 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12512 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12513 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12514 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12515 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12516 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12517 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12518 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12520 digest
[0] -= SHA512M_A
;
12521 digest
[1] -= SHA512M_B
;
12522 digest
[2] -= SHA512M_C
;
12523 digest
[3] -= SHA512M_D
;
12524 digest
[4] -= SHA512M_E
;
12525 digest
[5] -= SHA512M_F
;
12526 digest
[6] -= SHA512M_G
;
12527 digest
[7] -= SHA512M_H
;
12529 return (PARSER_OK
);
12532 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12534 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12536 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12540 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12543 u64
*digest
= (u64
*) hash_buf
->digest
;
12545 salt_t
*salt
= hash_buf
->salt
;
12547 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12548 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12549 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12550 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12551 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12552 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12553 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12554 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12556 digest
[0] -= SHA512M_A
;
12557 digest
[1] -= SHA512M_B
;
12558 digest
[2] -= SHA512M_C
;
12559 digest
[3] -= SHA512M_D
;
12560 digest
[4] -= SHA512M_E
;
12561 digest
[5] -= SHA512M_F
;
12562 digest
[6] -= SHA512M_G
;
12563 digest
[7] -= SHA512M_H
;
12565 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12567 uint salt_len
= input_len
- 128 - 1;
12569 char *salt_buf
= input_buf
+ 128 + 1;
12571 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12573 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12577 salt
->salt_len
= salt_len
;
12579 return (PARSER_OK
);
12582 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12584 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12586 u64
*digest
= (u64
*) hash_buf
->digest
;
12588 salt_t
*salt
= hash_buf
->salt
;
12590 char *salt_pos
= input_buf
+ 3;
12592 uint iterations_len
= 0;
12594 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12598 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12600 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12601 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12605 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12609 iterations_len
+= 8;
12613 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12616 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12618 char *hash_pos
= strchr (salt_pos
, '$');
12620 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12622 uint salt_len
= hash_pos
- salt_pos
;
12624 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12626 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12628 salt
->salt_len
= salt_len
;
12632 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12634 return (PARSER_OK
);
12637 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12639 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12641 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12643 u64
*digest
= (u64
*) hash_buf
->digest
;
12645 salt_t
*salt
= hash_buf
->salt
;
12647 uint keccak_mdlen
= input_len
/ 2;
12649 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12651 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12653 digest
[i
] = byte_swap_64 (digest
[i
]);
12656 salt
->keccak_mdlen
= keccak_mdlen
;
12658 return (PARSER_OK
);
12661 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12663 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12665 u32
*digest
= (u32
*) hash_buf
->digest
;
12667 salt_t
*salt
= hash_buf
->salt
;
12669 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12672 * Parse that strange long line
12677 size_t in_len
[9] = { 0 };
12679 in_off
[0] = strtok (input_buf
, ":");
12681 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12683 in_len
[0] = strlen (in_off
[0]);
12687 for (i
= 1; i
< 9; i
++)
12689 in_off
[i
] = strtok (NULL
, ":");
12691 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12693 in_len
[i
] = strlen (in_off
[i
]);
12696 char *ptr
= (char *) ikepsk
->msg_buf
;
12698 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12699 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12700 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12701 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12702 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12703 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12707 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12709 ptr
= (char *) ikepsk
->nr_buf
;
12711 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12712 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12716 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12719 * Store to database
12724 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12725 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12726 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12727 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12729 digest
[0] = byte_swap_32 (digest
[0]);
12730 digest
[1] = byte_swap_32 (digest
[1]);
12731 digest
[2] = byte_swap_32 (digest
[2]);
12732 digest
[3] = byte_swap_32 (digest
[3]);
12734 salt
->salt_len
= 32;
12736 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12737 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12738 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12739 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12740 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12741 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12742 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12743 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12745 return (PARSER_OK
);
12748 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12750 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12752 u32
*digest
= (u32
*) hash_buf
->digest
;
12754 salt_t
*salt
= hash_buf
->salt
;
12756 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12759 * Parse that strange long line
12764 size_t in_len
[9] = { 0 };
12766 in_off
[0] = strtok (input_buf
, ":");
12768 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12770 in_len
[0] = strlen (in_off
[0]);
12774 for (i
= 1; i
< 9; i
++)
12776 in_off
[i
] = strtok (NULL
, ":");
12778 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12780 in_len
[i
] = strlen (in_off
[i
]);
12783 char *ptr
= (char *) ikepsk
->msg_buf
;
12785 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12786 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12787 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12788 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12789 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12790 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12794 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12796 ptr
= (char *) ikepsk
->nr_buf
;
12798 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12799 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12803 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12806 * Store to database
12811 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12812 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12813 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12814 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12815 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12817 salt
->salt_len
= 32;
12819 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12820 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12821 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12822 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12823 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12824 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12825 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12826 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12828 return (PARSER_OK
);
12831 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12833 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12835 u32
*digest
= (u32
*) hash_buf
->digest
;
12837 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12838 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12839 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12840 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12841 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12843 digest
[0] = byte_swap_32 (digest
[0]);
12844 digest
[1] = byte_swap_32 (digest
[1]);
12845 digest
[2] = byte_swap_32 (digest
[2]);
12846 digest
[3] = byte_swap_32 (digest
[3]);
12847 digest
[4] = byte_swap_32 (digest
[4]);
12849 return (PARSER_OK
);
12852 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12854 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12856 u32
*digest
= (u32
*) hash_buf
->digest
;
12858 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12859 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12860 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12861 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12862 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12863 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12864 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12865 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12866 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12867 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12868 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12869 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12870 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12871 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12872 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12873 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12875 return (PARSER_OK
);
12878 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12880 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12882 u32
*digest
= (u32
*) hash_buf
->digest
;
12884 salt_t
*salt
= hash_buf
->salt
;
12886 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12887 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12888 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12889 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12890 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12892 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12894 uint salt_len
= input_len
- 40 - 1;
12896 char *salt_buf
= input_buf
+ 40 + 1;
12898 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12900 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12902 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12904 salt
->salt_len
= salt_len
;
12906 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12908 return (PARSER_OK
);
12911 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12913 u32
*digest
= (u32
*) hash_buf
->digest
;
12915 salt_t
*salt
= hash_buf
->salt
;
12917 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12919 if (input_len
== 0)
12921 log_error ("TrueCrypt container not specified");
12926 FILE *fp
= fopen (input_buf
, "rb");
12930 log_error ("%s: %s", input_buf
, strerror (errno
));
12935 char buf
[512] = { 0 };
12937 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12941 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12943 memcpy (tc
->salt_buf
, buf
, 64);
12945 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12947 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12949 salt
->salt_len
= 4;
12951 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12953 tc
->signature
= 0x45555254; // "TRUE"
12955 digest
[0] = tc
->data_buf
[0];
12957 return (PARSER_OK
);
12960 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12962 u32
*digest
= (u32
*) hash_buf
->digest
;
12964 salt_t
*salt
= hash_buf
->salt
;
12966 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12968 if (input_len
== 0)
12970 log_error ("TrueCrypt container not specified");
12975 FILE *fp
= fopen (input_buf
, "rb");
12979 log_error ("%s: %s", input_buf
, strerror (errno
));
12984 char buf
[512] = { 0 };
12986 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12990 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12992 memcpy (tc
->salt_buf
, buf
, 64);
12994 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12996 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12998 salt
->salt_len
= 4;
13000 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13002 tc
->signature
= 0x45555254; // "TRUE"
13004 digest
[0] = tc
->data_buf
[0];
13006 return (PARSER_OK
);
13009 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13011 u32
*digest
= (u32
*) hash_buf
->digest
;
13013 salt_t
*salt
= hash_buf
->salt
;
13015 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13017 if (input_len
== 0)
13019 log_error ("VeraCrypt container not specified");
13024 FILE *fp
= fopen (input_buf
, "rb");
13028 log_error ("%s: %s", input_buf
, strerror (errno
));
13033 char buf
[512] = { 0 };
13035 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13039 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13041 memcpy (tc
->salt_buf
, buf
, 64);
13043 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13045 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13047 salt
->salt_len
= 4;
13049 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13051 tc
->signature
= 0x41524556; // "VERA"
13053 digest
[0] = tc
->data_buf
[0];
13055 return (PARSER_OK
);
13058 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13060 u32
*digest
= (u32
*) hash_buf
->digest
;
13062 salt_t
*salt
= hash_buf
->salt
;
13064 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13066 if (input_len
== 0)
13068 log_error ("VeraCrypt container not specified");
13073 FILE *fp
= fopen (input_buf
, "rb");
13077 log_error ("%s: %s", input_buf
, strerror (errno
));
13082 char buf
[512] = { 0 };
13084 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13088 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13090 memcpy (tc
->salt_buf
, buf
, 64);
13092 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13094 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13096 salt
->salt_len
= 4;
13098 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13100 tc
->signature
= 0x41524556; // "VERA"
13102 digest
[0] = tc
->data_buf
[0];
13104 return (PARSER_OK
);
13107 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13109 u32
*digest
= (u32
*) hash_buf
->digest
;
13111 salt_t
*salt
= hash_buf
->salt
;
13113 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13115 if (input_len
== 0)
13117 log_error ("VeraCrypt container not specified");
13122 FILE *fp
= fopen (input_buf
, "rb");
13126 log_error ("%s: %s", input_buf
, strerror (errno
));
13131 char buf
[512] = { 0 };
13133 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13137 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13139 memcpy (tc
->salt_buf
, buf
, 64);
13141 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13143 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13145 salt
->salt_len
= 4;
13147 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13149 tc
->signature
= 0x41524556; // "VERA"
13151 digest
[0] = tc
->data_buf
[0];
13153 return (PARSER_OK
);
13156 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13158 u32
*digest
= (u32
*) hash_buf
->digest
;
13160 salt_t
*salt
= hash_buf
->salt
;
13162 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13164 if (input_len
== 0)
13166 log_error ("VeraCrypt container not specified");
13171 FILE *fp
= fopen (input_buf
, "rb");
13175 log_error ("%s: %s", input_buf
, strerror (errno
));
13180 char buf
[512] = { 0 };
13182 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13186 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13188 memcpy (tc
->salt_buf
, buf
, 64);
13190 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13192 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13194 salt
->salt_len
= 4;
13196 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13198 tc
->signature
= 0x41524556; // "VERA"
13200 digest
[0] = tc
->data_buf
[0];
13202 return (PARSER_OK
);
13205 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13207 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13209 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13211 u32
*digest
= (u32
*) hash_buf
->digest
;
13213 salt_t
*salt
= hash_buf
->salt
;
13215 char *salt_pos
= input_buf
+ 6;
13217 char *hash_pos
= strchr (salt_pos
, '$');
13219 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13221 uint salt_len
= hash_pos
- salt_pos
;
13223 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13225 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13227 salt
->salt_len
= salt_len
;
13229 salt
->salt_iter
= 1000;
13233 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13235 return (PARSER_OK
);
13238 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13240 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13242 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13244 u32
*digest
= (u32
*) hash_buf
->digest
;
13246 salt_t
*salt
= hash_buf
->salt
;
13248 char *iter_pos
= input_buf
+ 7;
13250 char *salt_pos
= strchr (iter_pos
, '$');
13252 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13256 char *hash_pos
= strchr (salt_pos
, '$');
13258 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13260 uint salt_len
= hash_pos
- salt_pos
;
13262 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13264 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13266 salt
->salt_len
= salt_len
;
13268 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13270 salt
->salt_sign
[0] = atoi (salt_iter
);
13272 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13276 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13278 digest
[0] = byte_swap_32 (digest
[0]);
13279 digest
[1] = byte_swap_32 (digest
[1]);
13280 digest
[2] = byte_swap_32 (digest
[2]);
13281 digest
[3] = byte_swap_32 (digest
[3]);
13282 digest
[4] = byte_swap_32 (digest
[4]);
13284 return (PARSER_OK
);
13287 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13289 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13291 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13293 u32
*digest
= (u32
*) hash_buf
->digest
;
13295 salt_t
*salt
= hash_buf
->salt
;
13297 char *iter_pos
= input_buf
+ 9;
13299 char *salt_pos
= strchr (iter_pos
, '$');
13301 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13305 char *hash_pos
= strchr (salt_pos
, '$');
13307 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13309 uint salt_len
= hash_pos
- salt_pos
;
13311 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13313 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13315 salt
->salt_len
= salt_len
;
13317 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13319 salt
->salt_sign
[0] = atoi (salt_iter
);
13321 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13325 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13327 digest
[0] = byte_swap_32 (digest
[0]);
13328 digest
[1] = byte_swap_32 (digest
[1]);
13329 digest
[2] = byte_swap_32 (digest
[2]);
13330 digest
[3] = byte_swap_32 (digest
[3]);
13331 digest
[4] = byte_swap_32 (digest
[4]);
13332 digest
[5] = byte_swap_32 (digest
[5]);
13333 digest
[6] = byte_swap_32 (digest
[6]);
13334 digest
[7] = byte_swap_32 (digest
[7]);
13336 return (PARSER_OK
);
13339 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13341 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13343 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13345 u64
*digest
= (u64
*) hash_buf
->digest
;
13347 salt_t
*salt
= hash_buf
->salt
;
13349 char *iter_pos
= input_buf
+ 9;
13351 char *salt_pos
= strchr (iter_pos
, '$');
13353 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13357 char *hash_pos
= strchr (salt_pos
, '$');
13359 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13361 uint salt_len
= hash_pos
- salt_pos
;
13363 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13365 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13367 salt
->salt_len
= salt_len
;
13369 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13371 salt
->salt_sign
[0] = atoi (salt_iter
);
13373 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13377 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13379 digest
[0] = byte_swap_64 (digest
[0]);
13380 digest
[1] = byte_swap_64 (digest
[1]);
13381 digest
[2] = byte_swap_64 (digest
[2]);
13382 digest
[3] = byte_swap_64 (digest
[3]);
13383 digest
[4] = byte_swap_64 (digest
[4]);
13384 digest
[5] = byte_swap_64 (digest
[5]);
13385 digest
[6] = byte_swap_64 (digest
[6]);
13386 digest
[7] = byte_swap_64 (digest
[7]);
13388 return (PARSER_OK
);
13391 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13393 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13395 u32
*digest
= (u32
*) hash_buf
->digest
;
13397 salt_t
*salt
= hash_buf
->salt
;
13399 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13405 char *iterations_pos
= input_buf
;
13407 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13409 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13411 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13413 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13417 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13419 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13421 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13423 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13425 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13427 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13432 * pbkdf2 iterations
13435 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13438 * handle salt encoding
13441 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13443 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13445 const char p0
= saltbuf_pos
[i
+ 0];
13446 const char p1
= saltbuf_pos
[i
+ 1];
13448 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13449 | hex_convert (p0
) << 4;
13452 salt
->salt_len
= saltbuf_len
/ 2;
13455 * handle cipher encoding
13458 uint
*tmp
= (uint
*) mymalloc (32);
13460 char *cipherbuf_ptr
= (char *) tmp
;
13462 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13464 const char p0
= cipherbuf_pos
[i
+ 0];
13465 const char p1
= cipherbuf_pos
[i
+ 1];
13467 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13468 | hex_convert (p0
) << 4;
13471 // iv is stored at salt_buf 4 (length 16)
13472 // data is stored at salt_buf 8 (length 16)
13474 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13475 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13476 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13477 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13479 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13480 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13481 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13482 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13486 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13488 const char p0
= cipherbuf_pos
[j
+ 0];
13489 const char p1
= cipherbuf_pos
[j
+ 1];
13491 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13492 | hex_convert (p0
) << 4;
13499 digest
[0] = 0x10101010;
13500 digest
[1] = 0x10101010;
13501 digest
[2] = 0x10101010;
13502 digest
[3] = 0x10101010;
13504 return (PARSER_OK
);
13507 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13509 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13511 u32
*digest
= (u32
*) hash_buf
->digest
;
13513 salt_t
*salt
= hash_buf
->salt
;
13515 char *hashbuf_pos
= input_buf
;
13517 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13519 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13521 uint hash_len
= iterations_pos
- hashbuf_pos
;
13523 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13527 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13529 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13531 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13535 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13537 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13541 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13543 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13545 salt
->salt_len
= salt_len
;
13547 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13549 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13550 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13551 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13552 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13554 return (PARSER_OK
);
13557 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13559 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13561 u32
*digest
= (u32
*) hash_buf
->digest
;
13563 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13564 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13565 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13566 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13567 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13568 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13569 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13570 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13572 digest
[0] = byte_swap_32 (digest
[0]);
13573 digest
[1] = byte_swap_32 (digest
[1]);
13574 digest
[2] = byte_swap_32 (digest
[2]);
13575 digest
[3] = byte_swap_32 (digest
[3]);
13576 digest
[4] = byte_swap_32 (digest
[4]);
13577 digest
[5] = byte_swap_32 (digest
[5]);
13578 digest
[6] = byte_swap_32 (digest
[6]);
13579 digest
[7] = byte_swap_32 (digest
[7]);
13581 return (PARSER_OK
);
13584 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13586 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13588 u32
*digest
= (u32
*) hash_buf
->digest
;
13590 salt_t
*salt
= hash_buf
->salt
;
13592 char *salt_pos
= input_buf
+ 3;
13594 uint iterations_len
= 0;
13596 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13600 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13602 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13603 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13607 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13611 iterations_len
+= 8;
13615 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13618 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13620 char *hash_pos
= strchr (salt_pos
, '$');
13622 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13624 uint salt_len
= hash_pos
- salt_pos
;
13626 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13628 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13630 salt
->salt_len
= salt_len
;
13634 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13636 return (PARSER_OK
);
13639 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13641 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13643 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13645 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13647 u64
*digest
= (u64
*) hash_buf
->digest
;
13649 salt_t
*salt
= hash_buf
->salt
;
13651 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13653 char *iter_pos
= input_buf
+ 4;
13655 char *salt_pos
= strchr (iter_pos
, '$');
13657 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13661 char *hash_pos
= strchr (salt_pos
, '$');
13663 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13665 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13669 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13670 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13671 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13672 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13673 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13674 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13675 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13676 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13678 uint salt_len
= hash_pos
- salt_pos
- 1;
13680 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13682 salt
->salt_len
= salt_len
/ 2;
13684 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13685 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13686 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13687 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13688 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13689 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13690 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13691 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13693 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13694 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13695 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13696 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13697 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13698 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13699 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13700 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13701 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13702 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13704 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13706 salt
->salt_iter
= atoi (iter_pos
) - 1;
13708 return (PARSER_OK
);
13711 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13713 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13715 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13717 u32
*digest
= (u32
*) hash_buf
->digest
;
13719 salt_t
*salt
= hash_buf
->salt
;
13721 char *salt_pos
= input_buf
+ 14;
13723 char *hash_pos
= strchr (salt_pos
, '*');
13725 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13729 uint salt_len
= hash_pos
- salt_pos
- 1;
13731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13733 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13737 salt
->salt_len
= salt_len
;
13739 u8 tmp_buf
[100] = { 0 };
13741 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13743 memcpy (digest
, tmp_buf
, 32);
13745 digest
[0] = byte_swap_32 (digest
[0]);
13746 digest
[1] = byte_swap_32 (digest
[1]);
13747 digest
[2] = byte_swap_32 (digest
[2]);
13748 digest
[3] = byte_swap_32 (digest
[3]);
13749 digest
[4] = byte_swap_32 (digest
[4]);
13750 digest
[5] = byte_swap_32 (digest
[5]);
13751 digest
[6] = byte_swap_32 (digest
[6]);
13752 digest
[7] = byte_swap_32 (digest
[7]);
13754 digest
[0] -= SHA256M_A
;
13755 digest
[1] -= SHA256M_B
;
13756 digest
[2] -= SHA256M_C
;
13757 digest
[3] -= SHA256M_D
;
13758 digest
[4] -= SHA256M_E
;
13759 digest
[5] -= SHA256M_F
;
13760 digest
[6] -= SHA256M_G
;
13761 digest
[7] -= SHA256M_H
;
13763 return (PARSER_OK
);
13766 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13768 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13770 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13772 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13774 u64
*digest
= (u64
*) hash_buf
->digest
;
13776 salt_t
*salt
= hash_buf
->salt
;
13778 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13780 char *iter_pos
= input_buf
+ 19;
13782 char *salt_pos
= strchr (iter_pos
, '.');
13784 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13788 char *hash_pos
= strchr (salt_pos
, '.');
13790 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13792 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13796 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13797 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13798 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13799 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13800 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13801 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13802 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13803 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13805 uint salt_len
= hash_pos
- salt_pos
- 1;
13809 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13813 for (i
= 0; i
< salt_len
; i
++)
13815 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13818 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13819 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13821 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13823 salt
->salt_len
= salt_len
;
13825 salt
->salt_iter
= atoi (iter_pos
) - 1;
13827 return (PARSER_OK
);
13830 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13832 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13834 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13836 u64
*digest
= (u64
*) hash_buf
->digest
;
13838 salt_t
*salt
= hash_buf
->salt
;
13840 u8 tmp_buf
[120] = { 0 };
13842 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13844 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13846 memcpy (digest
, tmp_buf
, 64);
13848 digest
[0] = byte_swap_64 (digest
[0]);
13849 digest
[1] = byte_swap_64 (digest
[1]);
13850 digest
[2] = byte_swap_64 (digest
[2]);
13851 digest
[3] = byte_swap_64 (digest
[3]);
13852 digest
[4] = byte_swap_64 (digest
[4]);
13853 digest
[5] = byte_swap_64 (digest
[5]);
13854 digest
[6] = byte_swap_64 (digest
[6]);
13855 digest
[7] = byte_swap_64 (digest
[7]);
13857 digest
[0] -= SHA512M_A
;
13858 digest
[1] -= SHA512M_B
;
13859 digest
[2] -= SHA512M_C
;
13860 digest
[3] -= SHA512M_D
;
13861 digest
[4] -= SHA512M_E
;
13862 digest
[5] -= SHA512M_F
;
13863 digest
[6] -= SHA512M_G
;
13864 digest
[7] -= SHA512M_H
;
13866 int salt_len
= tmp_len
- 64;
13868 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13870 salt
->salt_len
= salt_len
;
13872 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13874 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13876 char *ptr
= (char *) salt
->salt_buf
;
13878 ptr
[salt
->salt_len
] = 0x80;
13881 return (PARSER_OK
);
13884 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13886 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13888 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13892 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13895 u32
*digest
= (u32
*) hash_buf
->digest
;
13897 salt_t
*salt
= hash_buf
->salt
;
13899 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13900 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13901 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13902 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13904 digest
[0] = byte_swap_32 (digest
[0]);
13905 digest
[1] = byte_swap_32 (digest
[1]);
13906 digest
[2] = byte_swap_32 (digest
[2]);
13907 digest
[3] = byte_swap_32 (digest
[3]);
13909 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13911 uint salt_len
= input_len
- 32 - 1;
13913 char *salt_buf
= input_buf
+ 32 + 1;
13915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13921 salt
->salt_len
= salt_len
;
13923 return (PARSER_OK
);
13926 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13928 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13930 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13934 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13937 u32
*digest
= (u32
*) hash_buf
->digest
;
13939 salt_t
*salt
= hash_buf
->salt
;
13941 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13942 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13943 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13944 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13945 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13947 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13949 uint salt_len
= input_len
- 40 - 1;
13951 char *salt_buf
= input_buf
+ 40 + 1;
13953 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13955 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13957 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13959 salt
->salt_len
= salt_len
;
13961 return (PARSER_OK
);
13964 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13966 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13968 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13972 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13975 u32
*digest
= (u32
*) hash_buf
->digest
;
13977 salt_t
*salt
= hash_buf
->salt
;
13979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13983 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13984 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13985 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13986 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13988 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13990 uint salt_len
= input_len
- 64 - 1;
13992 char *salt_buf
= input_buf
+ 64 + 1;
13994 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13996 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13998 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14000 salt
->salt_len
= salt_len
;
14002 return (PARSER_OK
);
14005 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14007 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14009 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14013 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14016 u64
*digest
= (u64
*) hash_buf
->digest
;
14018 salt_t
*salt
= hash_buf
->salt
;
14020 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14021 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14022 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14023 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14024 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14025 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14026 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14027 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14029 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14031 uint salt_len
= input_len
- 128 - 1;
14033 char *salt_buf
= input_buf
+ 128 + 1;
14035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14037 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14039 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14041 salt
->salt_len
= salt_len
;
14043 return (PARSER_OK
);
14046 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14048 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14050 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14052 u32
*digest
= (u32
*) hash_buf
->digest
;
14054 salt_t
*salt
= hash_buf
->salt
;
14056 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14062 char *user_pos
= input_buf
+ 10 + 1;
14064 char *realm_pos
= strchr (user_pos
, '$');
14066 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14068 uint user_len
= realm_pos
- user_pos
;
14070 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14074 char *salt_pos
= strchr (realm_pos
, '$');
14076 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14078 uint realm_len
= salt_pos
- realm_pos
;
14080 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14084 char *data_pos
= strchr (salt_pos
, '$');
14086 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14088 uint salt_len
= data_pos
- salt_pos
;
14090 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14094 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14096 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14102 memcpy (krb5pa
->user
, user_pos
, user_len
);
14103 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14104 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14106 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14108 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14110 const char p0
= data_pos
[i
+ 0];
14111 const char p1
= data_pos
[i
+ 1];
14113 *timestamp_ptr
++ = hex_convert (p1
) << 0
14114 | hex_convert (p0
) << 4;
14117 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14119 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14121 const char p0
= data_pos
[i
+ 0];
14122 const char p1
= data_pos
[i
+ 1];
14124 *checksum_ptr
++ = hex_convert (p1
) << 0
14125 | hex_convert (p0
) << 4;
14129 * copy some data to generic buffers to make sorting happy
14132 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14133 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14134 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14135 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14136 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14137 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14138 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14139 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14140 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14142 salt
->salt_len
= 36;
14144 digest
[0] = krb5pa
->checksum
[0];
14145 digest
[1] = krb5pa
->checksum
[1];
14146 digest
[2] = krb5pa
->checksum
[2];
14147 digest
[3] = krb5pa
->checksum
[3];
14149 return (PARSER_OK
);
14152 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14154 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14156 u32
*digest
= (u32
*) hash_buf
->digest
;
14158 salt_t
*salt
= hash_buf
->salt
;
14164 char *salt_pos
= input_buf
;
14166 char *hash_pos
= strchr (salt_pos
, '$');
14168 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14170 uint salt_len
= hash_pos
- salt_pos
;
14172 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14176 uint hash_len
= input_len
- 1 - salt_len
;
14178 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14186 for (uint i
= 0; i
< salt_len
; i
++)
14188 if (salt_pos
[i
] == ' ') continue;
14193 // SAP user names cannot be longer than 12 characters
14194 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14196 // SAP user name cannot start with ! or ?
14197 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14203 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14205 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14207 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14209 salt
->salt_len
= salt_len
;
14211 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14212 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14216 digest
[0] = byte_swap_32 (digest
[0]);
14217 digest
[1] = byte_swap_32 (digest
[1]);
14219 return (PARSER_OK
);
14222 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14224 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14226 u32
*digest
= (u32
*) hash_buf
->digest
;
14228 salt_t
*salt
= hash_buf
->salt
;
14234 char *salt_pos
= input_buf
;
14236 char *hash_pos
= strchr (salt_pos
, '$');
14238 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14240 uint salt_len
= hash_pos
- salt_pos
;
14242 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14246 uint hash_len
= input_len
- 1 - salt_len
;
14248 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14256 for (uint i
= 0; i
< salt_len
; i
++)
14258 if (salt_pos
[i
] == ' ') continue;
14263 // SAP user names cannot be longer than 12 characters
14264 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14265 // so far nobody complained so we stay with this because it helps in optimization
14266 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14268 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14270 // SAP user name cannot start with ! or ?
14271 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14283 salt
->salt_len
= salt_len
;
14285 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14286 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14287 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14288 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14289 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14291 return (PARSER_OK
);
14294 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14296 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14298 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14300 u64
*digest
= (u64
*) hash_buf
->digest
;
14302 salt_t
*salt
= hash_buf
->salt
;
14304 char *iter_pos
= input_buf
+ 3;
14306 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14308 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14310 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14312 salt
->salt_iter
= salt_iter
;
14314 char *salt_pos
= iter_pos
+ 1;
14318 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14320 salt
->salt_len
= salt_len
;
14322 char *hash_pos
= salt_pos
+ salt_len
;
14324 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14328 char *tmp
= (char *) salt
->salt_buf_pc
;
14330 tmp
[0] = hash_pos
[42];
14334 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14335 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14336 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14337 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14343 return (PARSER_OK
);
14346 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14348 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14350 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14352 u32
*digest
= (u32
*) hash_buf
->digest
;
14354 salt_t
*salt
= hash_buf
->salt
;
14356 char *salt_buf
= input_buf
+ 6;
14358 uint salt_len
= 16;
14360 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14362 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14364 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14366 salt
->salt_len
= salt_len
;
14368 char *hash_pos
= input_buf
+ 6 + 16;
14370 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14371 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14372 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14373 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14374 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14375 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14376 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14377 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14379 return (PARSER_OK
);
14382 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14384 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14386 u32
*digest
= (u32
*) hash_buf
->digest
;
14388 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14389 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14393 return (PARSER_OK
);
14396 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14398 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14400 u32
*digest
= (u32
*) hash_buf
->digest
;
14402 salt_t
*salt
= hash_buf
->salt
;
14404 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14406 char *saltbuf_pos
= input_buf
;
14408 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14410 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14412 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14414 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14415 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14417 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14421 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14423 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14425 char *salt_ptr
= (char *) saltbuf_pos
;
14426 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14431 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14433 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14436 rakp_ptr
[j
] = 0x80;
14438 rakp
->salt_len
= j
;
14440 for (i
= 0; i
< 64; i
++)
14442 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14445 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14446 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14447 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14448 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14449 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14450 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14451 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14452 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14454 salt
->salt_len
= 32; // muss min. 32 haben
14456 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14457 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14458 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14459 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14460 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14462 return (PARSER_OK
);
14465 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14467 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14469 u32
*digest
= (u32
*) hash_buf
->digest
;
14471 salt_t
*salt
= hash_buf
->salt
;
14473 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14475 char *salt_pos
= input_buf
+ 1;
14477 memcpy (salt
->salt_buf
, salt_pos
, 8);
14479 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14480 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14482 salt
->salt_len
= 8;
14484 char *hash_pos
= salt_pos
+ 8;
14486 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14487 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14488 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14489 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14490 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14492 digest
[0] -= SHA1M_A
;
14493 digest
[1] -= SHA1M_B
;
14494 digest
[2] -= SHA1M_C
;
14495 digest
[3] -= SHA1M_D
;
14496 digest
[4] -= SHA1M_E
;
14498 return (PARSER_OK
);
14501 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14503 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14505 u32
*digest
= (u32
*) hash_buf
->digest
;
14507 salt_t
*salt
= hash_buf
->salt
;
14509 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14510 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14511 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14512 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14514 digest
[0] = byte_swap_32 (digest
[0]);
14515 digest
[1] = byte_swap_32 (digest
[1]);
14516 digest
[2] = byte_swap_32 (digest
[2]);
14517 digest
[3] = byte_swap_32 (digest
[3]);
14519 digest
[0] -= MD5M_A
;
14520 digest
[1] -= MD5M_B
;
14521 digest
[2] -= MD5M_C
;
14522 digest
[3] -= MD5M_D
;
14524 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14526 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14528 u32
*salt_buf
= salt
->salt_buf
;
14530 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14531 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14532 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14533 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14535 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14536 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14537 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14538 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14540 salt
->salt_len
= 16 + 1;
14542 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14544 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14546 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14548 return (PARSER_OK
);
14551 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14553 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14555 u32
*digest
= (u32
*) hash_buf
->digest
;
14557 salt_t
*salt
= hash_buf
->salt
;
14559 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14565 char *hashbuf_pos
= input_buf
;
14567 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14569 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14571 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14573 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14577 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14579 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14581 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14583 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14587 char *databuf_pos
= strchr (iteration_pos
, ':');
14589 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14591 const uint iteration_len
= databuf_pos
- iteration_pos
;
14593 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14594 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14596 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14598 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14599 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14605 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14606 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14607 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14608 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14609 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14610 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14611 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14612 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14616 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14618 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14620 const char p0
= saltbuf_pos
[i
+ 0];
14621 const char p1
= saltbuf_pos
[i
+ 1];
14623 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14624 | hex_convert (p0
) << 4;
14627 salt
->salt_buf
[4] = 0x01000000;
14628 salt
->salt_buf
[5] = 0x80;
14630 salt
->salt_len
= saltbuf_len
/ 2;
14634 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14638 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14640 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14642 const char p0
= databuf_pos
[i
+ 0];
14643 const char p1
= databuf_pos
[i
+ 1];
14645 *databuf_ptr
++ = hex_convert (p1
) << 0
14646 | hex_convert (p0
) << 4;
14649 *databuf_ptr
++ = 0x80;
14651 for (uint i
= 0; i
< 512; i
++)
14653 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14656 cloudkey
->data_len
= databuf_len
/ 2;
14658 return (PARSER_OK
);
14661 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14663 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14665 u32
*digest
= (u32
*) hash_buf
->digest
;
14667 salt_t
*salt
= hash_buf
->salt
;
14673 char *hashbuf_pos
= input_buf
;
14675 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14677 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14679 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14681 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14685 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14687 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14689 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14691 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14693 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14697 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14699 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14701 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14703 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14705 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14709 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14711 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14712 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14714 // ok, the plan for this algorithm is the following:
14715 // we have 2 salts here, the domain-name and a random salt
14716 // while both are used in the initial transformation,
14717 // only the random salt is used in the following iterations
14718 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14719 // and one that includes only the real salt (stored into salt_buf[]).
14720 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14722 u8 tmp_buf
[100] = { 0 };
14724 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14726 memcpy (digest
, tmp_buf
, 20);
14728 digest
[0] = byte_swap_32 (digest
[0]);
14729 digest
[1] = byte_swap_32 (digest
[1]);
14730 digest
[2] = byte_swap_32 (digest
[2]);
14731 digest
[3] = byte_swap_32 (digest
[3]);
14732 digest
[4] = byte_swap_32 (digest
[4]);
14736 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14738 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14740 char *len_ptr
= NULL
;
14742 for (uint i
= 0; i
< domainbuf_len
; i
++)
14744 if (salt_buf_pc_ptr
[i
] == '.')
14746 len_ptr
= &salt_buf_pc_ptr
[i
];
14756 salt
->salt_buf_pc
[7] = domainbuf_len
;
14760 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14762 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14764 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14766 salt
->salt_len
= salt_len
;
14770 salt
->salt_iter
= atoi (iteration_pos
);
14772 return (PARSER_OK
);
14775 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14777 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14779 u32
*digest
= (u32
*) hash_buf
->digest
;
14781 salt_t
*salt
= hash_buf
->salt
;
14783 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14784 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14785 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14786 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14787 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14789 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14791 uint salt_len
= input_len
- 40 - 1;
14793 char *salt_buf
= input_buf
+ 40 + 1;
14795 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14797 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14799 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14801 salt
->salt_len
= salt_len
;
14803 return (PARSER_OK
);
14806 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14808 const u8 ascii_to_ebcdic
[] =
14810 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14811 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14812 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14813 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14814 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14815 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14816 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14817 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14818 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14819 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14820 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14821 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14822 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14823 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14824 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14825 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14828 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14830 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14832 u32
*digest
= (u32
*) hash_buf
->digest
;
14834 salt_t
*salt
= hash_buf
->salt
;
14836 char *salt_pos
= input_buf
+ 6 + 1;
14838 char *digest_pos
= strchr (salt_pos
, '*');
14840 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14842 uint salt_len
= digest_pos
- salt_pos
;
14844 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14846 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14848 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14852 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14853 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14855 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14857 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14859 salt
->salt_len
= salt_len
;
14861 for (uint i
= 0; i
< salt_len
; i
++)
14863 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14865 for (uint i
= salt_len
; i
< 8; i
++)
14867 salt_buf_pc_ptr
[i
] = 0x40;
14872 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14874 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14875 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14877 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14878 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14880 digest
[0] = byte_swap_32 (digest
[0]);
14881 digest
[1] = byte_swap_32 (digest
[1]);
14883 IP (digest
[0], digest
[1], tt
);
14885 digest
[0] = rotr32 (digest
[0], 29);
14886 digest
[1] = rotr32 (digest
[1], 29);
14890 return (PARSER_OK
);
14893 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14895 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14897 u32
*digest
= (u32
*) hash_buf
->digest
;
14899 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14900 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14901 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14902 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14904 digest
[0] = byte_swap_32 (digest
[0]);
14905 digest
[1] = byte_swap_32 (digest
[1]);
14906 digest
[2] = byte_swap_32 (digest
[2]);
14907 digest
[3] = byte_swap_32 (digest
[3]);
14909 return (PARSER_OK
);
14912 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14914 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14916 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14918 u32
*digest
= (u32
*) hash_buf
->digest
;
14920 salt_t
*salt
= hash_buf
->salt
;
14922 u8 tmp_buf
[120] = { 0 };
14924 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14926 tmp_buf
[3] += -4; // dont ask!
14928 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14930 salt
->salt_len
= 5;
14932 memcpy (digest
, tmp_buf
+ 5, 9);
14934 // yes, only 9 byte are needed to crack, but 10 to display
14936 salt
->salt_buf_pc
[7] = input_buf
[20];
14938 return (PARSER_OK
);
14941 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14943 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14945 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14947 u32
*digest
= (u32
*) hash_buf
->digest
;
14949 salt_t
*salt
= hash_buf
->salt
;
14951 u8 tmp_buf
[120] = { 0 };
14953 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14955 tmp_buf
[3] += -4; // dont ask!
14959 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14961 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)
14965 char tmp_iter_buf
[11] = { 0 };
14967 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14969 tmp_iter_buf
[10] = 0;
14971 salt
->salt_iter
= atoi (tmp_iter_buf
);
14973 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14975 return (PARSER_SALT_ITERATION
);
14978 salt
->salt_iter
--; // first round in init
14980 // 2 additional bytes for display only
14982 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14983 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14987 memcpy (digest
, tmp_buf
+ 28, 8);
14989 digest
[0] = byte_swap_32 (digest
[0]);
14990 digest
[1] = byte_swap_32 (digest
[1]);
14994 return (PARSER_OK
);
14997 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14999 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15001 u32
*digest
= (u32
*) hash_buf
->digest
;
15003 salt_t
*salt
= hash_buf
->salt
;
15005 char *salt_buf_pos
= input_buf
;
15007 char *hash_buf_pos
= salt_buf_pos
+ 6;
15009 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15010 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15011 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15012 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15013 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15014 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15015 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15016 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15018 digest
[0] -= SHA256M_A
;
15019 digest
[1] -= SHA256M_B
;
15020 digest
[2] -= SHA256M_C
;
15021 digest
[3] -= SHA256M_D
;
15022 digest
[4] -= SHA256M_E
;
15023 digest
[5] -= SHA256M_F
;
15024 digest
[6] -= SHA256M_G
;
15025 digest
[7] -= SHA256M_H
;
15027 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15029 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15031 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15033 salt
->salt_len
= salt_len
;
15035 return (PARSER_OK
);
15038 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15040 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15042 u32
*digest
= (u32
*) hash_buf
->digest
;
15044 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15046 salt_t
*salt
= hash_buf
->salt
;
15048 char *salt_buf
= input_buf
+ 6;
15050 char *digest_buf
= strchr (salt_buf
, '$');
15052 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15054 uint salt_len
= digest_buf
- salt_buf
;
15056 digest_buf
++; // skip the '$' symbol
15058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15064 salt
->salt_len
= salt_len
;
15066 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15067 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15068 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15069 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15071 digest
[0] = byte_swap_32 (digest
[0]);
15072 digest
[1] = byte_swap_32 (digest
[1]);
15073 digest
[2] = byte_swap_32 (digest
[2]);
15074 digest
[3] = byte_swap_32 (digest
[3]);
15076 digest
[0] -= MD5M_A
;
15077 digest
[1] -= MD5M_B
;
15078 digest
[2] -= MD5M_C
;
15079 digest
[3] -= MD5M_D
;
15081 return (PARSER_OK
);
15084 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15086 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15088 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15090 u32
*digest
= (u32
*) hash_buf
->digest
;
15092 salt_t
*salt
= hash_buf
->salt
;
15094 char *salt_buf
= input_buf
+ 3;
15096 char *digest_buf
= strchr (salt_buf
, '$');
15098 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15100 uint salt_len
= digest_buf
- salt_buf
;
15102 digest_buf
++; // skip the '$' symbol
15104 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15106 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15108 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15110 salt_buf_ptr
[salt_len
] = 0x2d;
15112 salt
->salt_len
= salt_len
+ 1;
15114 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15115 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15116 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15117 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15119 digest
[0] = byte_swap_32 (digest
[0]);
15120 digest
[1] = byte_swap_32 (digest
[1]);
15121 digest
[2] = byte_swap_32 (digest
[2]);
15122 digest
[3] = byte_swap_32 (digest
[3]);
15124 digest
[0] -= MD5M_A
;
15125 digest
[1] -= MD5M_B
;
15126 digest
[2] -= MD5M_C
;
15127 digest
[3] -= MD5M_D
;
15129 return (PARSER_OK
);
15132 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15134 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15136 u32
*digest
= (u32
*) hash_buf
->digest
;
15138 salt_t
*salt
= hash_buf
->salt
;
15140 u8 tmp_buf
[100] = { 0 };
15142 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15144 memcpy (digest
, tmp_buf
, 20);
15146 digest
[0] = byte_swap_32 (digest
[0]);
15147 digest
[1] = byte_swap_32 (digest
[1]);
15148 digest
[2] = byte_swap_32 (digest
[2]);
15149 digest
[3] = byte_swap_32 (digest
[3]);
15150 digest
[4] = byte_swap_32 (digest
[4]);
15152 digest
[0] -= SHA1M_A
;
15153 digest
[1] -= SHA1M_B
;
15154 digest
[2] -= SHA1M_C
;
15155 digest
[3] -= SHA1M_D
;
15156 digest
[4] -= SHA1M_E
;
15158 salt
->salt_buf
[0] = 0x80;
15160 salt
->salt_len
= 0;
15162 return (PARSER_OK
);
15165 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15167 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15169 u32
*digest
= (u32
*) hash_buf
->digest
;
15171 salt_t
*salt
= hash_buf
->salt
;
15173 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15174 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15175 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15176 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15178 digest
[0] = byte_swap_32 (digest
[0]);
15179 digest
[1] = byte_swap_32 (digest
[1]);
15180 digest
[2] = byte_swap_32 (digest
[2]);
15181 digest
[3] = byte_swap_32 (digest
[3]);
15183 digest
[0] -= MD5M_A
;
15184 digest
[1] -= MD5M_B
;
15185 digest
[2] -= MD5M_C
;
15186 digest
[3] -= MD5M_D
;
15188 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15190 uint salt_len
= input_len
- 32 - 1;
15192 char *salt_buf
= input_buf
+ 32 + 1;
15194 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15196 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15198 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15201 * add static "salt" part
15204 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15208 salt
->salt_len
= salt_len
;
15210 return (PARSER_OK
);
15213 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15215 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15217 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15219 u32
*digest
= (u32
*) hash_buf
->digest
;
15221 salt_t
*salt
= hash_buf
->salt
;
15223 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15229 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15231 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15233 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15235 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15237 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15241 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15243 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15245 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15247 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15251 char *keybuf_pos
= strchr (keylen_pos
, '$');
15253 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15255 uint keylen_len
= keybuf_pos
- keylen_pos
;
15257 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15261 char *databuf_pos
= strchr (keybuf_pos
, '$');
15263 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15265 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15267 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15271 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15273 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15279 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15280 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15281 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15282 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15284 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15285 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15286 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15287 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15289 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15290 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15291 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15292 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15294 salt
->salt_len
= 16;
15295 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15297 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15299 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15302 return (PARSER_OK
);
15305 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15307 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15309 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15311 u32
*digest
= (u32
*) hash_buf
->digest
;
15313 salt_t
*salt
= hash_buf
->salt
;
15319 // first is the N salt parameter
15321 char *N_pos
= input_buf
+ 6;
15323 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15327 salt
->scrypt_N
= atoi (N_pos
);
15331 char *r_pos
= strchr (N_pos
, ':');
15333 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15337 salt
->scrypt_r
= atoi (r_pos
);
15341 char *p_pos
= strchr (r_pos
, ':');
15343 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15347 salt
->scrypt_p
= atoi (p_pos
);
15351 char *saltbuf_pos
= strchr (p_pos
, ':');
15353 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15357 char *hash_pos
= strchr (saltbuf_pos
, ':');
15359 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15365 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15367 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15369 u8 tmp_buf
[33] = { 0 };
15371 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15373 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15375 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15377 salt
->salt_len
= tmp_len
;
15378 salt
->salt_iter
= 1;
15380 // digest - base64 decode
15382 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15384 tmp_len
= input_len
- (hash_pos
- input_buf
);
15386 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15388 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15390 memcpy (digest
, tmp_buf
, 32);
15392 return (PARSER_OK
);
15395 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15397 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15399 u32
*digest
= (u32
*) hash_buf
->digest
;
15401 salt_t
*salt
= hash_buf
->salt
;
15407 char decrypted
[76] = { 0 }; // iv + hash
15409 juniper_decrypt_hash (input_buf
, decrypted
);
15411 char *md5crypt_hash
= decrypted
+ 12;
15413 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15415 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15417 char *salt_pos
= md5crypt_hash
+ 3;
15419 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15421 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15423 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15427 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15429 return (PARSER_OK
);
15432 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15434 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15436 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15438 u32
*digest
= (u32
*) hash_buf
->digest
;
15440 salt_t
*salt
= hash_buf
->salt
;
15442 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15448 // first is *raw* salt
15450 char *salt_pos
= input_buf
+ 3;
15452 char *hash_pos
= strchr (salt_pos
, '$');
15454 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15456 uint salt_len
= hash_pos
- salt_pos
;
15458 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15462 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15464 memcpy (salt_buf_ptr
, salt_pos
, 14);
15466 salt_buf_ptr
[17] = 0x01;
15467 salt_buf_ptr
[18] = 0x80;
15469 // add some stuff to normal salt to make sorted happy
15471 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15472 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15473 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15474 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15476 salt
->salt_len
= salt_len
;
15477 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15479 // base64 decode hash
15481 u8 tmp_buf
[100] = { 0 };
15483 uint hash_len
= input_len
- 3 - salt_len
- 1;
15485 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15487 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15489 memcpy (digest
, tmp_buf
, 32);
15491 digest
[0] = byte_swap_32 (digest
[0]);
15492 digest
[1] = byte_swap_32 (digest
[1]);
15493 digest
[2] = byte_swap_32 (digest
[2]);
15494 digest
[3] = byte_swap_32 (digest
[3]);
15495 digest
[4] = byte_swap_32 (digest
[4]);
15496 digest
[5] = byte_swap_32 (digest
[5]);
15497 digest
[6] = byte_swap_32 (digest
[6]);
15498 digest
[7] = byte_swap_32 (digest
[7]);
15500 return (PARSER_OK
);
15503 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15505 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15507 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15509 u32
*digest
= (u32
*) hash_buf
->digest
;
15511 salt_t
*salt
= hash_buf
->salt
;
15517 // first is *raw* salt
15519 char *salt_pos
= input_buf
+ 3;
15521 char *hash_pos
= strchr (salt_pos
, '$');
15523 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15525 uint salt_len
= hash_pos
- salt_pos
;
15527 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15529 salt
->salt_len
= salt_len
;
15532 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15534 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15535 salt_buf_ptr
[salt_len
] = 0;
15537 // base64 decode hash
15539 u8 tmp_buf
[100] = { 0 };
15541 uint hash_len
= input_len
- 3 - salt_len
- 1;
15543 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15545 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15547 memcpy (digest
, tmp_buf
, 32);
15550 salt
->scrypt_N
= 16384;
15551 salt
->scrypt_r
= 1;
15552 salt
->scrypt_p
= 1;
15553 salt
->salt_iter
= 1;
15555 return (PARSER_OK
);
15558 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15560 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15562 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15564 u32
*digest
= (u32
*) hash_buf
->digest
;
15566 salt_t
*salt
= hash_buf
->salt
;
15568 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15574 char *version_pos
= input_buf
+ 8 + 1;
15576 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15578 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15580 u32 version_len
= verifierHashSize_pos
- version_pos
;
15582 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15584 verifierHashSize_pos
++;
15586 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15588 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15590 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15592 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15596 char *saltSize_pos
= strchr (keySize_pos
, '*');
15598 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15600 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15602 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15606 char *osalt_pos
= strchr (saltSize_pos
, '*');
15608 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15610 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15612 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15616 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15618 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15620 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15622 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15624 encryptedVerifier_pos
++;
15626 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15628 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15630 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15632 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15634 encryptedVerifierHash_pos
++;
15636 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;
15638 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15640 const uint version
= atoi (version_pos
);
15642 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15644 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15646 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15648 const uint keySize
= atoi (keySize_pos
);
15650 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15652 office2007
->keySize
= keySize
;
15654 const uint saltSize
= atoi (saltSize_pos
);
15656 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15662 salt
->salt_len
= 16;
15663 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15665 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15666 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15667 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15668 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15674 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15675 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15676 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15677 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15679 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15680 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15681 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15682 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15683 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15689 digest
[0] = office2007
->encryptedVerifierHash
[0];
15690 digest
[1] = office2007
->encryptedVerifierHash
[1];
15691 digest
[2] = office2007
->encryptedVerifierHash
[2];
15692 digest
[3] = office2007
->encryptedVerifierHash
[3];
15694 return (PARSER_OK
);
15697 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15699 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15701 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15703 u32
*digest
= (u32
*) hash_buf
->digest
;
15705 salt_t
*salt
= hash_buf
->salt
;
15707 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15713 char *version_pos
= input_buf
+ 8 + 1;
15715 char *spinCount_pos
= strchr (version_pos
, '*');
15717 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15719 u32 version_len
= spinCount_pos
- version_pos
;
15721 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15725 char *keySize_pos
= strchr (spinCount_pos
, '*');
15727 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15729 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15731 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15735 char *saltSize_pos
= strchr (keySize_pos
, '*');
15737 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15739 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15741 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15745 char *osalt_pos
= strchr (saltSize_pos
, '*');
15747 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15749 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15751 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15755 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15757 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15759 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15761 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15763 encryptedVerifier_pos
++;
15765 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15767 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15769 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15771 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15773 encryptedVerifierHash_pos
++;
15775 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;
15777 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15779 const uint version
= atoi (version_pos
);
15781 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15783 const uint spinCount
= atoi (spinCount_pos
);
15785 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15787 const uint keySize
= atoi (keySize_pos
);
15789 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15791 const uint saltSize
= atoi (saltSize_pos
);
15793 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15799 salt
->salt_len
= 16;
15800 salt
->salt_iter
= spinCount
;
15802 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15803 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15804 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15805 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15811 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15812 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15813 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15814 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15816 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15817 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15818 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15819 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15820 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15821 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15822 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15823 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15829 digest
[0] = office2010
->encryptedVerifierHash
[0];
15830 digest
[1] = office2010
->encryptedVerifierHash
[1];
15831 digest
[2] = office2010
->encryptedVerifierHash
[2];
15832 digest
[3] = office2010
->encryptedVerifierHash
[3];
15834 return (PARSER_OK
);
15837 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15839 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15841 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15843 u32
*digest
= (u32
*) hash_buf
->digest
;
15845 salt_t
*salt
= hash_buf
->salt
;
15847 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15853 char *version_pos
= input_buf
+ 8 + 1;
15855 char *spinCount_pos
= strchr (version_pos
, '*');
15857 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15859 u32 version_len
= spinCount_pos
- version_pos
;
15861 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15865 char *keySize_pos
= strchr (spinCount_pos
, '*');
15867 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15869 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15871 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15875 char *saltSize_pos
= strchr (keySize_pos
, '*');
15877 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15879 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15881 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15885 char *osalt_pos
= strchr (saltSize_pos
, '*');
15887 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15889 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15891 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15895 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15897 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15899 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15901 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15903 encryptedVerifier_pos
++;
15905 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15907 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15909 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15911 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15913 encryptedVerifierHash_pos
++;
15915 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;
15917 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15919 const uint version
= atoi (version_pos
);
15921 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15923 const uint spinCount
= atoi (spinCount_pos
);
15925 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15927 const uint keySize
= atoi (keySize_pos
);
15929 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15931 const uint saltSize
= atoi (saltSize_pos
);
15933 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15939 salt
->salt_len
= 16;
15940 salt
->salt_iter
= spinCount
;
15942 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15943 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15944 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15945 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15951 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15952 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15953 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15954 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15956 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15957 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15958 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15959 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15960 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15961 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15962 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15963 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15969 digest
[0] = office2013
->encryptedVerifierHash
[0];
15970 digest
[1] = office2013
->encryptedVerifierHash
[1];
15971 digest
[2] = office2013
->encryptedVerifierHash
[2];
15972 digest
[3] = office2013
->encryptedVerifierHash
[3];
15974 return (PARSER_OK
);
15977 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15979 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15981 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15983 u32
*digest
= (u32
*) hash_buf
->digest
;
15985 salt_t
*salt
= hash_buf
->salt
;
15987 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15993 char *version_pos
= input_buf
+ 11;
15995 char *osalt_pos
= strchr (version_pos
, '*');
15997 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15999 u32 version_len
= osalt_pos
- version_pos
;
16001 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16005 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16007 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16009 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16011 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16013 encryptedVerifier_pos
++;
16015 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16017 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16019 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16021 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16023 encryptedVerifierHash_pos
++;
16025 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16027 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16029 const uint version
= *version_pos
- 0x30;
16031 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16037 oldoffice01
->version
= version
;
16039 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16040 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16041 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16042 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16044 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16045 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16046 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16047 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16049 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16050 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16051 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16052 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16054 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16055 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16056 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16057 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16063 salt
->salt_len
= 16;
16065 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16066 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16067 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16068 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16070 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16071 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16072 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16073 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16075 // this is a workaround as office produces multiple documents with the same salt
16077 salt
->salt_len
+= 32;
16079 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16080 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16081 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16082 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16083 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16084 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16085 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16086 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16092 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16093 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16094 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16095 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16097 return (PARSER_OK
);
16100 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16102 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16105 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16107 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16109 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16111 u32
*digest
= (u32
*) hash_buf
->digest
;
16113 salt_t
*salt
= hash_buf
->salt
;
16115 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16121 char *version_pos
= input_buf
+ 11;
16123 char *osalt_pos
= strchr (version_pos
, '*');
16125 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16127 u32 version_len
= osalt_pos
- version_pos
;
16129 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16133 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16135 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16137 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16139 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16141 encryptedVerifier_pos
++;
16143 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16145 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16147 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16149 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16151 encryptedVerifierHash_pos
++;
16153 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16155 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16157 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16159 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16163 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16165 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16167 const uint version
= *version_pos
- 0x30;
16169 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16175 oldoffice01
->version
= version
;
16177 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16178 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16179 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16180 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16182 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16183 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16184 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16185 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16187 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16188 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16189 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16190 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16192 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16193 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16194 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16195 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16197 oldoffice01
->rc4key
[1] = 0;
16198 oldoffice01
->rc4key
[0] = 0;
16200 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16201 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16202 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16203 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16204 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16205 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16206 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16207 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16208 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16209 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16211 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16212 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16218 salt
->salt_len
= 16;
16220 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16221 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16222 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16223 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16225 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16226 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16227 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16228 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16230 // this is a workaround as office produces multiple documents with the same salt
16232 salt
->salt_len
+= 32;
16234 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16235 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16236 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16237 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16238 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16239 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16240 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16241 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16247 digest
[0] = oldoffice01
->rc4key
[0];
16248 digest
[1] = oldoffice01
->rc4key
[1];
16252 return (PARSER_OK
);
16255 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16257 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16259 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16261 u32
*digest
= (u32
*) hash_buf
->digest
;
16263 salt_t
*salt
= hash_buf
->salt
;
16265 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16271 char *version_pos
= input_buf
+ 11;
16273 char *osalt_pos
= strchr (version_pos
, '*');
16275 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16277 u32 version_len
= osalt_pos
- version_pos
;
16279 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16283 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16285 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16287 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16289 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16291 encryptedVerifier_pos
++;
16293 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16295 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16297 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16299 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16301 encryptedVerifierHash_pos
++;
16303 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16305 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16307 const uint version
= *version_pos
- 0x30;
16309 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16315 oldoffice34
->version
= version
;
16317 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16318 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16319 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16320 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16322 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16323 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16324 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16325 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16327 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16328 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16329 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16330 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16331 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16333 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16334 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16335 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16336 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16337 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16343 salt
->salt_len
= 16;
16345 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16346 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16347 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16348 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16350 // this is a workaround as office produces multiple documents with the same salt
16352 salt
->salt_len
+= 32;
16354 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16355 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16356 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16357 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16358 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16359 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16360 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16361 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16367 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16368 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16369 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16370 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16372 return (PARSER_OK
);
16375 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16377 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16379 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16382 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16384 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16386 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16388 u32
*digest
= (u32
*) hash_buf
->digest
;
16390 salt_t
*salt
= hash_buf
->salt
;
16392 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16398 char *version_pos
= input_buf
+ 11;
16400 char *osalt_pos
= strchr (version_pos
, '*');
16402 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16404 u32 version_len
= osalt_pos
- version_pos
;
16406 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16410 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16412 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16414 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16416 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16418 encryptedVerifier_pos
++;
16420 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16422 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16424 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16426 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16428 encryptedVerifierHash_pos
++;
16430 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16432 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16434 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16436 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16440 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16442 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16444 const uint version
= *version_pos
- 0x30;
16446 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16452 oldoffice34
->version
= version
;
16454 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16455 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16456 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16457 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16459 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16460 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16461 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16462 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16464 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16465 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16466 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16467 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16468 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16470 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16471 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16472 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16473 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16474 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16476 oldoffice34
->rc4key
[1] = 0;
16477 oldoffice34
->rc4key
[0] = 0;
16479 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16480 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16481 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16482 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16483 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16484 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16485 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16486 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16487 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16488 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16490 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16491 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16497 salt
->salt_len
= 16;
16499 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16500 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16501 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16502 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16504 // this is a workaround as office produces multiple documents with the same salt
16506 salt
->salt_len
+= 32;
16508 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16509 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16510 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16511 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16512 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16513 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16514 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16515 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16521 digest
[0] = oldoffice34
->rc4key
[0];
16522 digest
[1] = oldoffice34
->rc4key
[1];
16526 return (PARSER_OK
);
16529 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16531 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16533 u32
*digest
= (u32
*) hash_buf
->digest
;
16535 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16536 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16537 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16538 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16540 digest
[0] = byte_swap_32 (digest
[0]);
16541 digest
[1] = byte_swap_32 (digest
[1]);
16542 digest
[2] = byte_swap_32 (digest
[2]);
16543 digest
[3] = byte_swap_32 (digest
[3]);
16545 return (PARSER_OK
);
16548 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16550 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16552 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16554 u32
*digest
= (u32
*) hash_buf
->digest
;
16556 salt_t
*salt
= hash_buf
->salt
;
16558 char *signature_pos
= input_buf
;
16560 char *salt_pos
= strchr (signature_pos
, '$');
16562 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16564 u32 signature_len
= salt_pos
- signature_pos
;
16566 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16570 char *hash_pos
= strchr (salt_pos
, '$');
16572 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16574 u32 salt_len
= hash_pos
- salt_pos
;
16576 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16580 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16582 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16584 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16585 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16586 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16587 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16588 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16590 digest
[0] -= SHA1M_A
;
16591 digest
[1] -= SHA1M_B
;
16592 digest
[2] -= SHA1M_C
;
16593 digest
[3] -= SHA1M_D
;
16594 digest
[4] -= SHA1M_E
;
16596 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16598 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16600 salt
->salt_len
= salt_len
;
16602 return (PARSER_OK
);
16605 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16607 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16609 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16611 u32
*digest
= (u32
*) hash_buf
->digest
;
16613 salt_t
*salt
= hash_buf
->salt
;
16615 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16621 char *iter_pos
= input_buf
+ 14;
16623 const int iter
= atoi (iter_pos
);
16625 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16627 salt
->salt_iter
= iter
- 1;
16629 char *salt_pos
= strchr (iter_pos
, '$');
16631 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16635 char *hash_pos
= strchr (salt_pos
, '$');
16637 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16639 const uint salt_len
= hash_pos
- salt_pos
;
16643 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16645 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16647 salt
->salt_len
= salt_len
;
16649 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16650 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16652 // add some stuff to normal salt to make sorted happy
16654 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16655 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16656 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16657 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16658 salt
->salt_buf
[4] = salt
->salt_iter
;
16660 // base64 decode hash
16662 u8 tmp_buf
[100] = { 0 };
16664 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16666 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16668 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16670 memcpy (digest
, tmp_buf
, 32);
16672 digest
[0] = byte_swap_32 (digest
[0]);
16673 digest
[1] = byte_swap_32 (digest
[1]);
16674 digest
[2] = byte_swap_32 (digest
[2]);
16675 digest
[3] = byte_swap_32 (digest
[3]);
16676 digest
[4] = byte_swap_32 (digest
[4]);
16677 digest
[5] = byte_swap_32 (digest
[5]);
16678 digest
[6] = byte_swap_32 (digest
[6]);
16679 digest
[7] = byte_swap_32 (digest
[7]);
16681 return (PARSER_OK
);
16684 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16686 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16688 u32
*digest
= (u32
*) hash_buf
->digest
;
16690 salt_t
*salt
= hash_buf
->salt
;
16692 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16693 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16697 digest
[0] = byte_swap_32 (digest
[0]);
16698 digest
[1] = byte_swap_32 (digest
[1]);
16700 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16701 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16704 char iter_c
= input_buf
[17];
16705 char iter_d
= input_buf
[19];
16707 // atm only defaults, let's see if there's more request
16708 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16709 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16711 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16713 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16714 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16715 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16716 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16718 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16719 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16720 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16721 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16723 salt
->salt_len
= 16;
16725 return (PARSER_OK
);
16728 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16730 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16732 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16734 u32
*digest
= (u32
*) hash_buf
->digest
;
16736 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16738 salt_t
*salt
= hash_buf
->salt
;
16740 char *salt_pos
= input_buf
+ 10;
16742 char *hash_pos
= strchr (salt_pos
, '$');
16744 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16746 uint salt_len
= hash_pos
- salt_pos
;
16750 uint hash_len
= input_len
- 10 - salt_len
- 1;
16752 // base64 decode salt
16754 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16756 u8 tmp_buf
[100] = { 0 };
16758 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16760 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16762 tmp_buf
[salt_len
] = 0x80;
16764 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16766 salt
->salt_len
= salt_len
;
16768 // base64 decode hash
16770 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16772 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16774 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16776 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16778 uint user_len
= hash_len
- 32;
16780 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16782 user_len
--; // skip the trailing space
16784 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16785 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16786 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16787 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16789 digest
[0] = byte_swap_32 (digest
[0]);
16790 digest
[1] = byte_swap_32 (digest
[1]);
16791 digest
[2] = byte_swap_32 (digest
[2]);
16792 digest
[3] = byte_swap_32 (digest
[3]);
16794 // store username for host only (output hash if cracked)
16796 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16797 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16799 return (PARSER_OK
);
16802 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16804 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16806 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16808 u32
*digest
= (u32
*) hash_buf
->digest
;
16810 salt_t
*salt
= hash_buf
->salt
;
16812 char *iter_pos
= input_buf
+ 10;
16814 u32 iter
= atoi (iter_pos
);
16818 return (PARSER_SALT_ITERATION
);
16821 iter
--; // first iteration is special
16823 salt
->salt_iter
= iter
;
16825 char *base64_pos
= strchr (iter_pos
, '}');
16827 if (base64_pos
== NULL
)
16829 return (PARSER_SIGNATURE_UNMATCHED
);
16834 // base64 decode salt
16836 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16838 u8 tmp_buf
[100] = { 0 };
16840 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16842 if (decoded_len
< 24)
16844 return (PARSER_SALT_LENGTH
);
16849 uint salt_len
= decoded_len
- 20;
16851 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16852 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16854 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16856 salt
->salt_len
= salt_len
;
16860 u32
*digest_ptr
= (u32
*) tmp_buf
;
16862 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16863 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16864 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16865 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16866 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16868 return (PARSER_OK
);
16871 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16873 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16875 u32
*digest
= (u32
*) hash_buf
->digest
;
16877 salt_t
*salt
= hash_buf
->salt
;
16879 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16880 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16881 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16882 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16883 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16885 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16887 uint salt_len
= input_len
- 40 - 1;
16889 char *salt_buf
= input_buf
+ 40 + 1;
16891 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16893 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16895 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16897 salt
->salt_len
= salt_len
;
16899 return (PARSER_OK
);
16902 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16904 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16906 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16908 u32
*digest
= (u32
*) hash_buf
->digest
;
16910 salt_t
*salt
= hash_buf
->salt
;
16912 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16918 char *V_pos
= input_buf
+ 5;
16920 char *R_pos
= strchr (V_pos
, '*');
16922 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16924 u32 V_len
= R_pos
- V_pos
;
16928 char *bits_pos
= strchr (R_pos
, '*');
16930 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16932 u32 R_len
= bits_pos
- R_pos
;
16936 char *P_pos
= strchr (bits_pos
, '*');
16938 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16940 u32 bits_len
= P_pos
- bits_pos
;
16944 char *enc_md_pos
= strchr (P_pos
, '*');
16946 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16948 u32 P_len
= enc_md_pos
- P_pos
;
16952 char *id_len_pos
= strchr (enc_md_pos
, '*');
16954 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16956 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16960 char *id_buf_pos
= strchr (id_len_pos
, '*');
16962 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16964 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16968 char *u_len_pos
= strchr (id_buf_pos
, '*');
16970 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16972 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16974 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16978 char *u_buf_pos
= strchr (u_len_pos
, '*');
16980 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16982 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16986 char *o_len_pos
= strchr (u_buf_pos
, '*');
16988 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16990 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16992 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16996 char *o_buf_pos
= strchr (o_len_pos
, '*');
16998 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17000 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17004 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;
17006 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17010 const int V
= atoi (V_pos
);
17011 const int R
= atoi (R_pos
);
17012 const int P
= atoi (P_pos
);
17014 if (V
!= 1) return (PARSER_SALT_VALUE
);
17015 if (R
!= 2) return (PARSER_SALT_VALUE
);
17017 const int enc_md
= atoi (enc_md_pos
);
17019 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17021 const int id_len
= atoi (id_len_pos
);
17022 const int u_len
= atoi (u_len_pos
);
17023 const int o_len
= atoi (o_len_pos
);
17025 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17026 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17027 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17029 const int bits
= atoi (bits_pos
);
17031 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17033 // copy data to esalt
17039 pdf
->enc_md
= enc_md
;
17041 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17042 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17043 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17044 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17045 pdf
->id_len
= id_len
;
17047 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17048 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17049 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17050 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17051 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17052 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17053 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17054 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17055 pdf
->u_len
= u_len
;
17057 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17058 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17059 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17060 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17061 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17062 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17063 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17064 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17065 pdf
->o_len
= o_len
;
17067 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17068 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17069 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17070 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17072 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17073 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17074 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17075 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17076 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17077 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17078 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17079 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17081 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17082 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17083 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17084 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17085 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17086 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17087 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17088 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17090 // we use ID for salt, maybe needs to change, we will see...
17092 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17093 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17094 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17095 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17096 salt
->salt_len
= pdf
->id_len
;
17098 digest
[0] = pdf
->u_buf
[0];
17099 digest
[1] = pdf
->u_buf
[1];
17100 digest
[2] = pdf
->u_buf
[2];
17101 digest
[3] = pdf
->u_buf
[3];
17103 return (PARSER_OK
);
17106 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17108 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17111 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17113 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17115 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17117 u32
*digest
= (u32
*) hash_buf
->digest
;
17119 salt_t
*salt
= hash_buf
->salt
;
17121 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17127 char *V_pos
= input_buf
+ 5;
17129 char *R_pos
= strchr (V_pos
, '*');
17131 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 V_len
= R_pos
- V_pos
;
17137 char *bits_pos
= strchr (R_pos
, '*');
17139 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 R_len
= bits_pos
- R_pos
;
17145 char *P_pos
= strchr (bits_pos
, '*');
17147 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 u32 bits_len
= P_pos
- bits_pos
;
17153 char *enc_md_pos
= strchr (P_pos
, '*');
17155 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 u32 P_len
= enc_md_pos
- P_pos
;
17161 char *id_len_pos
= strchr (enc_md_pos
, '*');
17163 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17169 char *id_buf_pos
= strchr (id_len_pos
, '*');
17171 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17177 char *u_len_pos
= strchr (id_buf_pos
, '*');
17179 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17181 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17183 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17187 char *u_buf_pos
= strchr (u_len_pos
, '*');
17189 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17191 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17195 char *o_len_pos
= strchr (u_buf_pos
, '*');
17197 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17199 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17201 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17205 char *o_buf_pos
= strchr (o_len_pos
, '*');
17207 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17209 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17213 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17215 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17217 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17219 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17223 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;
17225 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17229 const int V
= atoi (V_pos
);
17230 const int R
= atoi (R_pos
);
17231 const int P
= atoi (P_pos
);
17233 if (V
!= 1) return (PARSER_SALT_VALUE
);
17234 if (R
!= 2) return (PARSER_SALT_VALUE
);
17236 const int enc_md
= atoi (enc_md_pos
);
17238 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17240 const int id_len
= atoi (id_len_pos
);
17241 const int u_len
= atoi (u_len_pos
);
17242 const int o_len
= atoi (o_len_pos
);
17244 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17245 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17246 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17248 const int bits
= atoi (bits_pos
);
17250 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17252 // copy data to esalt
17258 pdf
->enc_md
= enc_md
;
17260 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17261 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17262 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17263 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17264 pdf
->id_len
= id_len
;
17266 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17267 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17268 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17269 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17270 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17271 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17272 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17273 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17274 pdf
->u_len
= u_len
;
17276 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17277 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17278 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17279 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17280 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17281 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17282 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17283 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17284 pdf
->o_len
= o_len
;
17286 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17287 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17288 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17289 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17291 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17292 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17293 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17294 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17295 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17296 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17297 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17298 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17300 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17301 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17302 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17303 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17304 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17305 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17306 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17307 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17309 pdf
->rc4key
[1] = 0;
17310 pdf
->rc4key
[0] = 0;
17312 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17313 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17314 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17315 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17316 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17317 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17318 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17319 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17320 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17321 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17323 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17324 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17326 // we use ID for salt, maybe needs to change, we will see...
17328 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17329 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17330 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17331 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17332 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17333 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17334 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17335 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17336 salt
->salt_len
= pdf
->id_len
+ 16;
17338 digest
[0] = pdf
->rc4key
[0];
17339 digest
[1] = pdf
->rc4key
[1];
17343 return (PARSER_OK
);
17346 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17348 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17350 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17352 u32
*digest
= (u32
*) hash_buf
->digest
;
17354 salt_t
*salt
= hash_buf
->salt
;
17356 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17362 char *V_pos
= input_buf
+ 5;
17364 char *R_pos
= strchr (V_pos
, '*');
17366 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 V_len
= R_pos
- V_pos
;
17372 char *bits_pos
= strchr (R_pos
, '*');
17374 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17376 u32 R_len
= bits_pos
- R_pos
;
17380 char *P_pos
= strchr (bits_pos
, '*');
17382 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17384 u32 bits_len
= P_pos
- bits_pos
;
17388 char *enc_md_pos
= strchr (P_pos
, '*');
17390 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17392 u32 P_len
= enc_md_pos
- P_pos
;
17396 char *id_len_pos
= strchr (enc_md_pos
, '*');
17398 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17400 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17404 char *id_buf_pos
= strchr (id_len_pos
, '*');
17406 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17408 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17412 char *u_len_pos
= strchr (id_buf_pos
, '*');
17414 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17416 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17418 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17422 char *u_buf_pos
= strchr (u_len_pos
, '*');
17424 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17426 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17430 char *o_len_pos
= strchr (u_buf_pos
, '*');
17432 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17434 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17436 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17440 char *o_buf_pos
= strchr (o_len_pos
, '*');
17442 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17444 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17448 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;
17450 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17454 const int V
= atoi (V_pos
);
17455 const int R
= atoi (R_pos
);
17456 const int P
= atoi (P_pos
);
17460 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17461 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17463 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17465 const int id_len
= atoi (id_len_pos
);
17466 const int u_len
= atoi (u_len_pos
);
17467 const int o_len
= atoi (o_len_pos
);
17469 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17471 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17472 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17474 const int bits
= atoi (bits_pos
);
17476 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17482 enc_md
= atoi (enc_md_pos
);
17485 // copy data to esalt
17491 pdf
->enc_md
= enc_md
;
17493 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17494 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17495 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17496 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17500 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17501 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17502 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17503 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17506 pdf
->id_len
= id_len
;
17508 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17509 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17510 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17511 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17512 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17513 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17514 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17515 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17516 pdf
->u_len
= u_len
;
17518 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17519 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17520 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17521 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17522 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17523 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17524 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17525 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17526 pdf
->o_len
= o_len
;
17528 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17529 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17530 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17531 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17535 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17536 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17537 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17538 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17541 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17542 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17543 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17544 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17545 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17546 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17547 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17548 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17550 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17551 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17552 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17553 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17554 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17555 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17556 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17557 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17559 // precompute rc4 data for later use
17575 uint salt_pc_block
[32] = { 0 };
17577 char *salt_pc_ptr
= (char *) salt_pc_block
;
17579 memcpy (salt_pc_ptr
, padding
, 32);
17580 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17582 uint salt_pc_digest
[4] = { 0 };
17584 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17586 pdf
->rc4data
[0] = salt_pc_digest
[0];
17587 pdf
->rc4data
[1] = salt_pc_digest
[1];
17589 // we use ID for salt, maybe needs to change, we will see...
17591 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17592 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17593 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17594 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17595 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17596 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17597 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17598 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17599 salt
->salt_len
= pdf
->id_len
+ 16;
17601 salt
->salt_iter
= ROUNDS_PDF14
;
17603 digest
[0] = pdf
->u_buf
[0];
17604 digest
[1] = pdf
->u_buf
[1];
17608 return (PARSER_OK
);
17611 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17613 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17615 if (ret
!= PARSER_OK
)
17620 u32
*digest
= (u32
*) hash_buf
->digest
;
17622 salt_t
*salt
= hash_buf
->salt
;
17624 digest
[0] -= SHA256M_A
;
17625 digest
[1] -= SHA256M_B
;
17626 digest
[2] -= SHA256M_C
;
17627 digest
[3] -= SHA256M_D
;
17628 digest
[4] -= SHA256M_E
;
17629 digest
[5] -= SHA256M_F
;
17630 digest
[6] -= SHA256M_G
;
17631 digest
[7] -= SHA256M_H
;
17633 salt
->salt_buf
[2] = 0x80;
17635 return (PARSER_OK
);
17638 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17640 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17642 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17644 u32
*digest
= (u32
*) hash_buf
->digest
;
17646 salt_t
*salt
= hash_buf
->salt
;
17648 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17654 char *V_pos
= input_buf
+ 5;
17656 char *R_pos
= strchr (V_pos
, '*');
17658 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17660 u32 V_len
= R_pos
- V_pos
;
17664 char *bits_pos
= strchr (R_pos
, '*');
17666 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17668 u32 R_len
= bits_pos
- R_pos
;
17672 char *P_pos
= strchr (bits_pos
, '*');
17674 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17676 u32 bits_len
= P_pos
- bits_pos
;
17680 char *enc_md_pos
= strchr (P_pos
, '*');
17682 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17684 u32 P_len
= enc_md_pos
- P_pos
;
17688 char *id_len_pos
= strchr (enc_md_pos
, '*');
17690 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17692 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17696 char *id_buf_pos
= strchr (id_len_pos
, '*');
17698 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17700 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17704 char *u_len_pos
= strchr (id_buf_pos
, '*');
17706 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17708 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17712 char *u_buf_pos
= strchr (u_len_pos
, '*');
17714 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17716 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17720 char *o_len_pos
= strchr (u_buf_pos
, '*');
17722 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17724 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17728 char *o_buf_pos
= strchr (o_len_pos
, '*');
17730 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17732 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17736 char *last
= strchr (o_buf_pos
, '*');
17738 if (last
== NULL
) last
= input_buf
+ input_len
;
17740 u32 o_buf_len
= last
- o_buf_pos
;
17744 const int V
= atoi (V_pos
);
17745 const int R
= atoi (R_pos
);
17749 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17750 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17752 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17754 const int bits
= atoi (bits_pos
);
17756 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17758 int enc_md
= atoi (enc_md_pos
);
17760 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17762 const uint id_len
= atoi (id_len_pos
);
17763 const uint u_len
= atoi (u_len_pos
);
17764 const uint o_len
= atoi (o_len_pos
);
17766 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17767 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17768 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17769 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17770 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17771 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17772 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17773 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17775 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17776 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17777 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17779 // copy data to esalt
17781 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17783 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17785 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17788 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17789 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17791 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17792 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17794 salt
->salt_len
= 8;
17795 salt
->salt_iter
= ROUNDS_PDF17L8
;
17797 digest
[0] = pdf
->u_buf
[0];
17798 digest
[1] = pdf
->u_buf
[1];
17799 digest
[2] = pdf
->u_buf
[2];
17800 digest
[3] = pdf
->u_buf
[3];
17801 digest
[4] = pdf
->u_buf
[4];
17802 digest
[5] = pdf
->u_buf
[5];
17803 digest
[6] = pdf
->u_buf
[6];
17804 digest
[7] = pdf
->u_buf
[7];
17806 return (PARSER_OK
);
17809 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17811 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17813 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17815 u32
*digest
= (u32
*) hash_buf
->digest
;
17817 salt_t
*salt
= hash_buf
->salt
;
17819 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17827 char *iter_pos
= input_buf
+ 7;
17829 u32 iter
= atoi (iter_pos
);
17831 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17832 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17834 // first is *raw* salt
17836 char *salt_pos
= strchr (iter_pos
, ':');
17838 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17842 char *hash_pos
= strchr (salt_pos
, ':');
17844 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17846 u32 salt_len
= hash_pos
- salt_pos
;
17848 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17852 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17854 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17858 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17860 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17862 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17864 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17865 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17867 salt
->salt_len
= salt_len
;
17868 salt
->salt_iter
= iter
- 1;
17872 u8 tmp_buf
[100] = { 0 };
17874 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17876 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17878 memcpy (digest
, tmp_buf
, 16);
17880 digest
[0] = byte_swap_32 (digest
[0]);
17881 digest
[1] = byte_swap_32 (digest
[1]);
17882 digest
[2] = byte_swap_32 (digest
[2]);
17883 digest
[3] = byte_swap_32 (digest
[3]);
17885 // add some stuff to normal salt to make sorted happy
17887 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17888 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17889 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17890 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17891 salt
->salt_buf
[4] = salt
->salt_iter
;
17893 return (PARSER_OK
);
17896 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17898 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17900 u32
*digest
= (u32
*) hash_buf
->digest
;
17902 salt_t
*salt
= hash_buf
->salt
;
17904 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17905 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17906 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17907 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17909 digest
[0] = byte_swap_32 (digest
[0]);
17910 digest
[1] = byte_swap_32 (digest
[1]);
17911 digest
[2] = byte_swap_32 (digest
[2]);
17912 digest
[3] = byte_swap_32 (digest
[3]);
17914 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17916 uint salt_len
= input_len
- 32 - 1;
17918 char *salt_buf
= input_buf
+ 32 + 1;
17920 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17922 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17924 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17926 salt
->salt_len
= salt_len
;
17928 return (PARSER_OK
);
17931 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17933 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17935 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17937 u32
*digest
= (u32
*) hash_buf
->digest
;
17939 salt_t
*salt
= hash_buf
->salt
;
17941 char *user_pos
= input_buf
+ 10;
17943 char *salt_pos
= strchr (user_pos
, '*');
17945 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17949 char *hash_pos
= strchr (salt_pos
, '*');
17953 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17955 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17957 uint user_len
= salt_pos
- user_pos
- 1;
17959 uint salt_len
= hash_pos
- salt_pos
- 1;
17961 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17967 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17968 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17969 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17970 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17972 digest
[0] = byte_swap_32 (digest
[0]);
17973 digest
[1] = byte_swap_32 (digest
[1]);
17974 digest
[2] = byte_swap_32 (digest
[2]);
17975 digest
[3] = byte_swap_32 (digest
[3]);
17977 digest
[0] -= MD5M_A
;
17978 digest
[1] -= MD5M_B
;
17979 digest
[2] -= MD5M_C
;
17980 digest
[3] -= MD5M_D
;
17986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17988 // first 4 bytes are the "challenge"
17990 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17991 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17992 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17993 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17995 // append the user name
17997 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17999 salt
->salt_len
= 4 + user_len
;
18001 return (PARSER_OK
);
18004 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18006 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18008 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18010 u32
*digest
= (u32
*) hash_buf
->digest
;
18012 salt_t
*salt
= hash_buf
->salt
;
18014 char *salt_pos
= input_buf
+ 9;
18016 char *hash_pos
= strchr (salt_pos
, '*');
18018 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18022 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18024 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18026 uint salt_len
= hash_pos
- salt_pos
- 1;
18028 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18034 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18035 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18036 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18037 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18038 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18044 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18046 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18048 salt
->salt_len
= salt_len
;
18050 return (PARSER_OK
);
18053 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18055 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18057 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18059 u32
*digest
= (u32
*) hash_buf
->digest
;
18061 salt_t
*salt
= hash_buf
->salt
;
18063 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18069 char *cry_master_len_pos
= input_buf
+ 9;
18071 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18073 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18075 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18077 cry_master_buf_pos
++;
18079 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18081 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18083 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18085 cry_salt_len_pos
++;
18087 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18089 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18091 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18093 cry_salt_buf_pos
++;
18095 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18097 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18099 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18103 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18105 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18107 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18111 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18113 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18115 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18119 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18121 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18123 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18125 public_key_len_pos
++;
18127 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18129 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18131 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18133 public_key_buf_pos
++;
18135 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;
18137 const uint cry_master_len
= atoi (cry_master_len_pos
);
18138 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18139 const uint ckey_len
= atoi (ckey_len_pos
);
18140 const uint public_key_len
= atoi (public_key_len_pos
);
18142 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18143 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18144 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18145 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18147 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18149 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18151 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18154 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18156 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18158 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18161 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18163 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18165 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18168 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18169 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18170 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18173 * store digest (should be unique enought, hopefully)
18176 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18177 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18178 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18179 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18185 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18187 const uint cry_rounds
= atoi (cry_rounds_pos
);
18189 salt
->salt_iter
= cry_rounds
- 1;
18191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18193 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18195 salt
->salt_len
= salt_len
;
18197 return (PARSER_OK
);
18200 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18202 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18204 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18206 u32
*digest
= (u32
*) hash_buf
->digest
;
18208 salt_t
*salt
= hash_buf
->salt
;
18210 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18212 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18214 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18216 memcpy (temp_input_buf
, input_buf
, input_len
);
18220 char *URI_server_pos
= temp_input_buf
+ 6;
18222 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18224 if (URI_client_pos
== NULL
)
18226 myfree (temp_input_buf
);
18228 return (PARSER_SEPARATOR_UNMATCHED
);
18231 URI_client_pos
[0] = 0;
18234 uint URI_server_len
= strlen (URI_server_pos
);
18236 if (URI_server_len
> 512)
18238 myfree (temp_input_buf
);
18240 return (PARSER_SALT_LENGTH
);
18245 char *user_pos
= strchr (URI_client_pos
, '*');
18247 if (user_pos
== NULL
)
18249 myfree (temp_input_buf
);
18251 return (PARSER_SEPARATOR_UNMATCHED
);
18257 uint URI_client_len
= strlen (URI_client_pos
);
18259 if (URI_client_len
> 512)
18261 myfree (temp_input_buf
);
18263 return (PARSER_SALT_LENGTH
);
18268 char *realm_pos
= strchr (user_pos
, '*');
18270 if (realm_pos
== NULL
)
18272 myfree (temp_input_buf
);
18274 return (PARSER_SEPARATOR_UNMATCHED
);
18280 uint user_len
= strlen (user_pos
);
18282 if (user_len
> 116)
18284 myfree (temp_input_buf
);
18286 return (PARSER_SALT_LENGTH
);
18291 char *method_pos
= strchr (realm_pos
, '*');
18293 if (method_pos
== NULL
)
18295 myfree (temp_input_buf
);
18297 return (PARSER_SEPARATOR_UNMATCHED
);
18303 uint realm_len
= strlen (realm_pos
);
18305 if (realm_len
> 116)
18307 myfree (temp_input_buf
);
18309 return (PARSER_SALT_LENGTH
);
18314 char *URI_prefix_pos
= strchr (method_pos
, '*');
18316 if (URI_prefix_pos
== NULL
)
18318 myfree (temp_input_buf
);
18320 return (PARSER_SEPARATOR_UNMATCHED
);
18323 URI_prefix_pos
[0] = 0;
18326 uint method_len
= strlen (method_pos
);
18328 if (method_len
> 246)
18330 myfree (temp_input_buf
);
18332 return (PARSER_SALT_LENGTH
);
18337 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18339 if (URI_resource_pos
== NULL
)
18341 myfree (temp_input_buf
);
18343 return (PARSER_SEPARATOR_UNMATCHED
);
18346 URI_resource_pos
[0] = 0;
18347 URI_resource_pos
++;
18349 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18351 if (URI_prefix_len
> 245)
18353 myfree (temp_input_buf
);
18355 return (PARSER_SALT_LENGTH
);
18360 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18362 if (URI_suffix_pos
== NULL
)
18364 myfree (temp_input_buf
);
18366 return (PARSER_SEPARATOR_UNMATCHED
);
18369 URI_suffix_pos
[0] = 0;
18372 uint URI_resource_len
= strlen (URI_resource_pos
);
18374 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18376 myfree (temp_input_buf
);
18378 return (PARSER_SALT_LENGTH
);
18383 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18385 if (nonce_pos
== NULL
)
18387 myfree (temp_input_buf
);
18389 return (PARSER_SEPARATOR_UNMATCHED
);
18395 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18397 if (URI_suffix_len
> 245)
18399 myfree (temp_input_buf
);
18401 return (PARSER_SALT_LENGTH
);
18406 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18408 if (nonce_client_pos
== NULL
)
18410 myfree (temp_input_buf
);
18412 return (PARSER_SEPARATOR_UNMATCHED
);
18415 nonce_client_pos
[0] = 0;
18416 nonce_client_pos
++;
18418 uint nonce_len
= strlen (nonce_pos
);
18420 if (nonce_len
< 1 || nonce_len
> 50)
18422 myfree (temp_input_buf
);
18424 return (PARSER_SALT_LENGTH
);
18429 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18431 if (nonce_count_pos
== NULL
)
18433 myfree (temp_input_buf
);
18435 return (PARSER_SEPARATOR_UNMATCHED
);
18438 nonce_count_pos
[0] = 0;
18441 uint nonce_client_len
= strlen (nonce_client_pos
);
18443 if (nonce_client_len
> 50)
18445 myfree (temp_input_buf
);
18447 return (PARSER_SALT_LENGTH
);
18452 char *qop_pos
= strchr (nonce_count_pos
, '*');
18454 if (qop_pos
== NULL
)
18456 myfree (temp_input_buf
);
18458 return (PARSER_SEPARATOR_UNMATCHED
);
18464 uint nonce_count_len
= strlen (nonce_count_pos
);
18466 if (nonce_count_len
> 50)
18468 myfree (temp_input_buf
);
18470 return (PARSER_SALT_LENGTH
);
18475 char *directive_pos
= strchr (qop_pos
, '*');
18477 if (directive_pos
== NULL
)
18479 myfree (temp_input_buf
);
18481 return (PARSER_SEPARATOR_UNMATCHED
);
18484 directive_pos
[0] = 0;
18487 uint qop_len
= strlen (qop_pos
);
18491 myfree (temp_input_buf
);
18493 return (PARSER_SALT_LENGTH
);
18498 char *digest_pos
= strchr (directive_pos
, '*');
18500 if (digest_pos
== NULL
)
18502 myfree (temp_input_buf
);
18504 return (PARSER_SEPARATOR_UNMATCHED
);
18510 uint directive_len
= strlen (directive_pos
);
18512 if (directive_len
!= 3)
18514 myfree (temp_input_buf
);
18516 return (PARSER_SALT_LENGTH
);
18519 if (memcmp (directive_pos
, "MD5", 3))
18521 log_info ("ERROR: only the MD5 directive is currently supported\n");
18523 myfree (temp_input_buf
);
18525 return (PARSER_SIP_AUTH_DIRECTIVE
);
18529 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18534 uint md5_max_len
= 4 * 64;
18536 uint md5_remaining_len
= md5_max_len
;
18538 uint tmp_md5_buf
[64] = { 0 };
18540 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18542 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18544 md5_len
+= method_len
+ 1;
18545 tmp_md5_ptr
+= method_len
+ 1;
18547 if (URI_prefix_len
> 0)
18549 md5_remaining_len
= md5_max_len
- md5_len
;
18551 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18553 md5_len
+= URI_prefix_len
+ 1;
18554 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18557 md5_remaining_len
= md5_max_len
- md5_len
;
18559 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18561 md5_len
+= URI_resource_len
;
18562 tmp_md5_ptr
+= URI_resource_len
;
18564 if (URI_suffix_len
> 0)
18566 md5_remaining_len
= md5_max_len
- md5_len
;
18568 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18570 md5_len
+= 1 + URI_suffix_len
;
18573 uint tmp_digest
[4] = { 0 };
18575 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18577 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18578 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18579 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18580 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18586 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18588 uint esalt_len
= 0;
18590 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18592 // there are 2 possibilities for the esalt:
18594 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18596 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18598 if (esalt_len
> max_esalt_len
)
18600 myfree (temp_input_buf
);
18602 return (PARSER_SALT_LENGTH
);
18605 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18617 esalt_len
= 1 + nonce_len
+ 1 + 32;
18619 if (esalt_len
> max_esalt_len
)
18621 myfree (temp_input_buf
);
18623 return (PARSER_SALT_LENGTH
);
18626 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18634 // add 0x80 to esalt
18636 esalt_buf_ptr
[esalt_len
] = 0x80;
18638 sip
->esalt_len
= esalt_len
;
18644 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18646 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18648 uint max_salt_len
= 119;
18650 if (salt_len
> max_salt_len
)
18652 myfree (temp_input_buf
);
18654 return (PARSER_SALT_LENGTH
);
18657 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18659 sip
->salt_len
= salt_len
;
18662 * fake salt (for sorting)
18665 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18669 uint fake_salt_len
= salt_len
;
18671 if (fake_salt_len
> max_salt_len
)
18673 fake_salt_len
= max_salt_len
;
18676 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18678 salt
->salt_len
= fake_salt_len
;
18684 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18685 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18686 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18687 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18689 digest
[0] = byte_swap_32 (digest
[0]);
18690 digest
[1] = byte_swap_32 (digest
[1]);
18691 digest
[2] = byte_swap_32 (digest
[2]);
18692 digest
[3] = byte_swap_32 (digest
[3]);
18694 myfree (temp_input_buf
);
18696 return (PARSER_OK
);
18699 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18701 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18703 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18705 u32
*digest
= (u32
*) hash_buf
->digest
;
18707 salt_t
*salt
= hash_buf
->salt
;
18711 char *digest_pos
= input_buf
;
18713 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18720 char *salt_buf
= input_buf
+ 8 + 1;
18724 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18726 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18728 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18730 salt
->salt_len
= salt_len
;
18732 return (PARSER_OK
);
18735 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18737 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18739 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18741 u32
*digest
= (u32
*) hash_buf
->digest
;
18743 salt_t
*salt
= hash_buf
->salt
;
18745 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18751 char *p_buf_pos
= input_buf
+ 4;
18753 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18755 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18757 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18759 NumCyclesPower_pos
++;
18761 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18763 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18765 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18769 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18771 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18773 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18777 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18779 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18781 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18785 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18787 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18789 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18793 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18795 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18797 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18801 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18803 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18805 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18809 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18811 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18813 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18817 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18819 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18821 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18825 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;
18827 const uint iter
= atoi (NumCyclesPower_pos
);
18828 const uint crc
= atoi (crc_buf_pos
);
18829 const uint p_buf
= atoi (p_buf_pos
);
18830 const uint salt_len
= atoi (salt_len_pos
);
18831 const uint iv_len
= atoi (iv_len_pos
);
18832 const uint unpack_size
= atoi (unpack_size_pos
);
18833 const uint data_len
= atoi (data_len_pos
);
18839 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18840 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18842 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18844 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18846 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18852 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18853 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18854 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18855 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18857 seven_zip
->iv_len
= iv_len
;
18859 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18861 seven_zip
->salt_len
= 0;
18863 seven_zip
->crc
= crc
;
18865 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18867 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18869 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18872 seven_zip
->data_len
= data_len
;
18874 seven_zip
->unpack_size
= unpack_size
;
18878 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18879 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18880 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18881 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18883 salt
->salt_len
= 16;
18885 salt
->salt_sign
[0] = iter
;
18887 salt
->salt_iter
= 1 << iter
;
18898 return (PARSER_OK
);
18901 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18903 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18905 u32
*digest
= (u32
*) hash_buf
->digest
;
18907 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18908 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18909 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18910 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18911 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18912 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18913 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18914 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18916 digest
[0] = byte_swap_32 (digest
[0]);
18917 digest
[1] = byte_swap_32 (digest
[1]);
18918 digest
[2] = byte_swap_32 (digest
[2]);
18919 digest
[3] = byte_swap_32 (digest
[3]);
18920 digest
[4] = byte_swap_32 (digest
[4]);
18921 digest
[5] = byte_swap_32 (digest
[5]);
18922 digest
[6] = byte_swap_32 (digest
[6]);
18923 digest
[7] = byte_swap_32 (digest
[7]);
18925 return (PARSER_OK
);
18928 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18930 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18932 u32
*digest
= (u32
*) hash_buf
->digest
;
18934 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18935 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18936 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18937 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18938 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18939 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18940 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18941 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18942 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18943 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18944 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18945 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18946 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18947 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18948 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18949 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18951 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18952 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18953 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18954 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18955 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18956 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18957 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18958 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18959 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18960 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18961 digest
[10] = byte_swap_32 (digest
[10]);
18962 digest
[11] = byte_swap_32 (digest
[11]);
18963 digest
[12] = byte_swap_32 (digest
[12]);
18964 digest
[13] = byte_swap_32 (digest
[13]);
18965 digest
[14] = byte_swap_32 (digest
[14]);
18966 digest
[15] = byte_swap_32 (digest
[15]);
18968 return (PARSER_OK
);
18971 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18973 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18975 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18977 u32
*digest
= (u32
*) hash_buf
->digest
;
18979 salt_t
*salt
= hash_buf
->salt
;
18981 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18989 char *iter_pos
= input_buf
+ 4;
18991 u32 iter
= atoi (iter_pos
);
18993 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18994 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18996 // first is *raw* salt
18998 char *salt_pos
= strchr (iter_pos
, ':');
19000 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19004 char *hash_pos
= strchr (salt_pos
, ':');
19006 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19008 u32 salt_len
= hash_pos
- salt_pos
;
19010 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19014 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19016 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19020 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19022 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19024 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19026 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19027 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19029 salt
->salt_len
= salt_len
;
19030 salt
->salt_iter
= iter
- 1;
19034 u8 tmp_buf
[100] = { 0 };
19036 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19038 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19040 memcpy (digest
, tmp_buf
, 16);
19042 // add some stuff to normal salt to make sorted happy
19044 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19045 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19046 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19047 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19048 salt
->salt_buf
[4] = salt
->salt_iter
;
19050 return (PARSER_OK
);
19053 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19055 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19057 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19059 u32
*digest
= (u32
*) hash_buf
->digest
;
19061 salt_t
*salt
= hash_buf
->salt
;
19063 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19071 char *iter_pos
= input_buf
+ 5;
19073 u32 iter
= atoi (iter_pos
);
19075 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19076 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19078 // first is *raw* salt
19080 char *salt_pos
= strchr (iter_pos
, ':');
19082 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19086 char *hash_pos
= strchr (salt_pos
, ':');
19088 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19090 u32 salt_len
= hash_pos
- salt_pos
;
19092 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19096 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19098 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19102 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19104 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19106 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19108 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19109 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19111 salt
->salt_len
= salt_len
;
19112 salt
->salt_iter
= iter
- 1;
19116 u8 tmp_buf
[100] = { 0 };
19118 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19120 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19122 memcpy (digest
, tmp_buf
, 16);
19124 digest
[0] = byte_swap_32 (digest
[0]);
19125 digest
[1] = byte_swap_32 (digest
[1]);
19126 digest
[2] = byte_swap_32 (digest
[2]);
19127 digest
[3] = byte_swap_32 (digest
[3]);
19129 // add some stuff to normal salt to make sorted happy
19131 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19132 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19133 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19134 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19135 salt
->salt_buf
[4] = salt
->salt_iter
;
19137 return (PARSER_OK
);
19140 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19142 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19144 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19146 u64
*digest
= (u64
*) hash_buf
->digest
;
19148 salt_t
*salt
= hash_buf
->salt
;
19150 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19158 char *iter_pos
= input_buf
+ 7;
19160 u32 iter
= atoi (iter_pos
);
19162 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19163 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19165 // first is *raw* salt
19167 char *salt_pos
= strchr (iter_pos
, ':');
19169 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19173 char *hash_pos
= strchr (salt_pos
, ':');
19175 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19177 u32 salt_len
= hash_pos
- salt_pos
;
19179 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19183 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19185 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19189 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19191 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19195 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19196 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19198 salt
->salt_len
= salt_len
;
19199 salt
->salt_iter
= iter
- 1;
19203 u8 tmp_buf
[100] = { 0 };
19205 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19207 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19209 memcpy (digest
, tmp_buf
, 64);
19211 digest
[0] = byte_swap_64 (digest
[0]);
19212 digest
[1] = byte_swap_64 (digest
[1]);
19213 digest
[2] = byte_swap_64 (digest
[2]);
19214 digest
[3] = byte_swap_64 (digest
[3]);
19215 digest
[4] = byte_swap_64 (digest
[4]);
19216 digest
[5] = byte_swap_64 (digest
[5]);
19217 digest
[6] = byte_swap_64 (digest
[6]);
19218 digest
[7] = byte_swap_64 (digest
[7]);
19220 // add some stuff to normal salt to make sorted happy
19222 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19223 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19224 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19225 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19226 salt
->salt_buf
[4] = salt
->salt_iter
;
19228 return (PARSER_OK
);
19231 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19233 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19235 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19237 uint
*digest
= (uint
*) hash_buf
->digest
;
19239 salt_t
*salt
= hash_buf
->salt
;
19245 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19247 char *hash_pos
= strchr (salt_pos
, '$');
19249 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19251 u32 salt_len
= hash_pos
- salt_pos
;
19253 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19257 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19259 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19263 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19264 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19282 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19283 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19285 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19286 salt
->salt_len
= 8;
19288 return (PARSER_OK
);
19291 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19293 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19295 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19297 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19299 if (c19
& 3) return (PARSER_HASH_VALUE
);
19301 salt_t
*salt
= hash_buf
->salt
;
19303 u32
*digest
= (u32
*) hash_buf
->digest
;
19307 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19308 | itoa64_to_int (input_buf
[2]) << 6
19309 | itoa64_to_int (input_buf
[3]) << 12
19310 | itoa64_to_int (input_buf
[4]) << 18;
19314 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19315 | itoa64_to_int (input_buf
[6]) << 6
19316 | itoa64_to_int (input_buf
[7]) << 12
19317 | itoa64_to_int (input_buf
[8]) << 18;
19319 salt
->salt_len
= 4;
19321 u8 tmp_buf
[100] = { 0 };
19323 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19325 memcpy (digest
, tmp_buf
, 8);
19329 IP (digest
[0], digest
[1], tt
);
19331 digest
[0] = rotr32 (digest
[0], 31);
19332 digest
[1] = rotr32 (digest
[1], 31);
19336 return (PARSER_OK
);
19339 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19341 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19343 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19345 u32
*digest
= (u32
*) hash_buf
->digest
;
19347 salt_t
*salt
= hash_buf
->salt
;
19353 char *type_pos
= input_buf
+ 6 + 1;
19355 char *salt_pos
= strchr (type_pos
, '*');
19357 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19359 u32 type_len
= salt_pos
- type_pos
;
19361 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19365 char *crypted_pos
= strchr (salt_pos
, '*');
19367 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19369 u32 salt_len
= crypted_pos
- salt_pos
;
19371 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19375 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19377 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19383 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19384 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19386 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19387 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19389 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19390 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19391 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19392 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19394 salt
->salt_len
= 24;
19395 salt
->salt_iter
= ROUNDS_RAR3
;
19397 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19398 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19400 digest
[0] = 0xc43d7b00;
19401 digest
[1] = 0x40070000;
19405 return (PARSER_OK
);
19408 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19410 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19412 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19414 u32
*digest
= (u32
*) hash_buf
->digest
;
19416 salt_t
*salt
= hash_buf
->salt
;
19418 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19424 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19426 char *param1_pos
= strchr (param0_pos
, '$');
19428 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19430 u32 param0_len
= param1_pos
- param0_pos
;
19434 char *param2_pos
= strchr (param1_pos
, '$');
19436 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19438 u32 param1_len
= param2_pos
- param1_pos
;
19442 char *param3_pos
= strchr (param2_pos
, '$');
19444 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19446 u32 param2_len
= param3_pos
- param2_pos
;
19450 char *param4_pos
= strchr (param3_pos
, '$');
19452 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19454 u32 param3_len
= param4_pos
- param3_pos
;
19458 char *param5_pos
= strchr (param4_pos
, '$');
19460 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19462 u32 param4_len
= param5_pos
- param4_pos
;
19466 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19468 char *salt_buf
= param1_pos
;
19469 char *iv
= param3_pos
;
19470 char *pswcheck
= param5_pos
;
19472 const uint salt_len
= atoi (param0_pos
);
19473 const uint iterations
= atoi (param2_pos
);
19474 const uint pswcheck_len
= atoi (param4_pos
);
19480 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19481 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19482 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19484 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19485 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19486 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19492 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19493 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19494 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19495 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19497 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19498 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19499 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19500 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19502 salt
->salt_len
= 16;
19504 salt
->salt_sign
[0] = iterations
;
19506 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19512 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19513 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19517 return (PARSER_OK
);
19520 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19522 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19524 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19526 u32
*digest
= (u32
*) hash_buf
->digest
;
19528 salt_t
*salt
= hash_buf
->salt
;
19530 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19537 char *account_pos
= input_buf
+ 11 + 1;
19543 if (account_pos
[0] == '*')
19547 data_pos
= strchr (account_pos
, '*');
19552 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19554 uint account_len
= data_pos
- account_pos
+ 1;
19556 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19561 data_len
= input_len
- 11 - 1 - account_len
- 2;
19563 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19567 /* assume $krb5tgs$23$checksum$edata2 */
19568 data_pos
= account_pos
;
19570 memcpy (krb5tgs
->account_info
, "**", 3);
19572 data_len
= input_len
- 11 - 1 - 1;
19575 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19577 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19579 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19581 const char p0
= data_pos
[i
+ 0];
19582 const char p1
= data_pos
[i
+ 1];
19584 *checksum_ptr
++ = hex_convert (p1
) << 0
19585 | hex_convert (p0
) << 4;
19588 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19590 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19593 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19595 const char p0
= data_pos
[i
+ 0];
19596 const char p1
= data_pos
[i
+ 1];
19597 *edata_ptr
++ = hex_convert (p1
) << 0
19598 | hex_convert (p0
) << 4;
19601 /* this is needed for hmac_md5 */
19602 *edata_ptr
++ = 0x80;
19604 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19605 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19606 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19607 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19609 salt
->salt_len
= 32;
19611 digest
[0] = krb5tgs
->checksum
[0];
19612 digest
[1] = krb5tgs
->checksum
[1];
19613 digest
[2] = krb5tgs
->checksum
[2];
19614 digest
[3] = krb5tgs
->checksum
[3];
19616 return (PARSER_OK
);
19619 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19621 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19623 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19625 u32
*digest
= (u32
*) hash_buf
->digest
;
19627 salt_t
*salt
= hash_buf
->salt
;
19634 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19638 char *wrapped_key_pos
;
19642 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19644 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19646 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19648 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19653 data_pos
= salt_pos
;
19655 wrapped_key_pos
= strchr (salt_pos
, '*');
19657 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19659 uint salt_len
= wrapped_key_pos
- salt_pos
;
19661 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19666 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19668 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19670 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19671 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19672 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19673 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19677 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19678 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19679 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19680 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19681 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19682 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19684 salt
->salt_len
= 40;
19686 digest
[0] = salt
->salt_buf
[0];
19687 digest
[1] = salt
->salt_buf
[1];
19688 digest
[2] = salt
->salt_buf
[2];
19689 digest
[3] = salt
->salt_buf
[3];
19691 return (PARSER_OK
);
19694 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19696 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19698 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19700 u32
*digest
= (u32
*) hash_buf
->digest
;
19702 salt_t
*salt
= hash_buf
->salt
;
19704 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19714 char *algorithm_pos
;
19716 char *final_random_seed_pos
;
19717 u32 final_random_seed_len
;
19719 char *transf_random_seed_pos
;
19720 u32 transf_random_seed_len
;
19725 /* default is no keyfile provided */
19726 char *keyfile_len_pos
;
19727 u32 keyfile_len
= 0;
19728 u32 is_keyfile_present
= 0;
19729 char *keyfile_inline_pos
;
19732 /* specific to version 1 */
19733 char *contents_len_pos
;
19735 char *contents_pos
;
19737 /* specific to version 2 */
19738 char *expected_bytes_pos
;
19739 u32 expected_bytes_len
;
19741 char *contents_hash_pos
;
19742 u32 contents_hash_len
;
19744 version_pos
= input_buf
+ 8 + 1 + 1;
19746 keepass
->version
= atoi (version_pos
);
19748 rounds_pos
= strchr (version_pos
, '*');
19750 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19754 salt
->salt_iter
= (atoi (rounds_pos
));
19756 algorithm_pos
= strchr (rounds_pos
, '*');
19758 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19762 keepass
->algorithm
= atoi (algorithm_pos
);
19764 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19766 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19768 final_random_seed_pos
++;
19770 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19771 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19772 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19773 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19775 if (keepass
->version
== 2)
19777 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19778 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19779 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19780 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19783 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19785 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19787 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19789 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19790 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19792 transf_random_seed_pos
++;
19794 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19795 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19796 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19797 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19798 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19799 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19800 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19801 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19803 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19805 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19807 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19809 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19813 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19814 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19815 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19816 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19818 if (keepass
->version
== 1)
19820 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19822 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19824 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19826 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19828 contents_hash_pos
++;
19830 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19831 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19832 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19833 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19834 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19835 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19836 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19837 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19839 /* get length of contents following */
19840 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19842 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19844 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19846 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19850 u32 inline_flag
= atoi (inline_flag_pos
);
19852 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19854 contents_len_pos
= strchr (inline_flag_pos
, '*');
19856 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19858 contents_len_pos
++;
19860 contents_len
= atoi (contents_len_pos
);
19862 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19864 contents_pos
= strchr (contents_len_pos
, '*');
19866 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19872 keepass
->contents_len
= contents_len
;
19874 contents_len
= contents_len
/ 4;
19876 keyfile_inline_pos
= strchr (contents_pos
, '*');
19878 u32 real_contents_len
;
19880 if (keyfile_inline_pos
== NULL
)
19881 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19884 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19885 keyfile_inline_pos
++;
19886 is_keyfile_present
= 1;
19889 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19891 for (i
= 0; i
< contents_len
; i
++)
19892 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19894 else if (keepass
->version
== 2)
19896 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19898 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19900 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19902 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19904 expected_bytes_pos
++;
19906 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19907 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19908 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19909 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19910 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19911 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19912 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19913 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19915 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19917 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19919 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19921 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19923 contents_hash_pos
++;
19925 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19926 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19927 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19928 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19929 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19930 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19931 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19932 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19934 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19936 if (keyfile_inline_pos
== NULL
)
19937 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19940 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19941 keyfile_inline_pos
++;
19942 is_keyfile_present
= 1;
19944 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19947 if (is_keyfile_present
!= 0)
19949 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19953 keyfile_len
= atoi (keyfile_len_pos
);
19955 keepass
->keyfile_len
= keyfile_len
;
19957 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19959 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19961 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19965 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19967 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19969 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19970 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19971 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19972 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19973 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19974 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19975 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19976 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19979 digest
[0] = keepass
->enc_iv
[0];
19980 digest
[1] = keepass
->enc_iv
[1];
19981 digest
[2] = keepass
->enc_iv
[2];
19982 digest
[3] = keepass
->enc_iv
[3];
19984 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19985 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19986 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19987 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19988 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19989 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19990 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19991 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19993 return (PARSER_OK
);
19996 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19998 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20000 u32
*digest
= (u32
*) hash_buf
->digest
;
20002 salt_t
*salt
= hash_buf
->salt
;
20004 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20005 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20006 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20007 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20008 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20009 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20010 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20011 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20013 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20015 uint salt_len
= input_len
- 64 - 1;
20017 char *salt_buf
= input_buf
+ 64 + 1;
20019 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20025 salt
->salt_len
= salt_len
;
20028 * we can precompute the first sha256 transform
20031 uint w
[16] = { 0 };
20033 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20034 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20035 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20036 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20037 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20038 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20039 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20040 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20041 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20042 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20043 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20044 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20045 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20046 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20047 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20048 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20050 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20052 sha256_64 (w
, pc256
);
20054 salt
->salt_buf_pc
[0] = pc256
[0];
20055 salt
->salt_buf_pc
[1] = pc256
[1];
20056 salt
->salt_buf_pc
[2] = pc256
[2];
20057 salt
->salt_buf_pc
[3] = pc256
[3];
20058 salt
->salt_buf_pc
[4] = pc256
[4];
20059 salt
->salt_buf_pc
[5] = pc256
[5];
20060 salt
->salt_buf_pc
[6] = pc256
[6];
20061 salt
->salt_buf_pc
[7] = pc256
[7];
20063 digest
[0] -= pc256
[0];
20064 digest
[1] -= pc256
[1];
20065 digest
[2] -= pc256
[2];
20066 digest
[3] -= pc256
[3];
20067 digest
[4] -= pc256
[4];
20068 digest
[5] -= pc256
[5];
20069 digest
[6] -= pc256
[6];
20070 digest
[7] -= pc256
[7];
20072 return (PARSER_OK
);
20075 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20077 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20079 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20081 u32
*digest
= (u32
*) hash_buf
->digest
;
20083 salt_t
*salt
= hash_buf
->salt
;
20089 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20091 char *data_buf_pos
= strchr (data_len_pos
, '$');
20093 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20095 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20097 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20098 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20102 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20104 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20106 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20108 u32 data_len
= atoi (data_len_pos
);
20110 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20116 char *salt_pos
= data_buf_pos
;
20118 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20119 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20120 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20121 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20123 // this is actually the CT, which is also the hash later (if matched)
20125 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20126 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20127 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20128 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20130 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20132 salt
->salt_iter
= 10 - 1;
20138 digest
[0] = salt
->salt_buf
[4];
20139 digest
[1] = salt
->salt_buf
[5];
20140 digest
[2] = salt
->salt_buf
[6];
20141 digest
[3] = salt
->salt_buf
[7];
20143 return (PARSER_OK
);
20146 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20148 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20150 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20152 u32
*digest
= (u32
*) hash_buf
->digest
;
20154 salt_t
*salt
= hash_buf
->salt
;
20160 char *salt_pos
= input_buf
+ 11 + 1;
20162 char *iter_pos
= strchr (salt_pos
, ',');
20164 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20166 u32 salt_len
= iter_pos
- salt_pos
;
20168 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20172 char *hash_pos
= strchr (iter_pos
, ',');
20174 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20176 u32 iter_len
= hash_pos
- iter_pos
;
20178 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20182 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20184 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20190 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20191 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20192 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20193 salt
->salt_buf
[3] = 0x00018000;
20195 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20196 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20197 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20198 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20200 salt
->salt_len
= salt_len
/ 2;
20202 salt
->salt_iter
= atoi (iter_pos
) - 1;
20208 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20209 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20210 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20211 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20212 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20213 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20214 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20215 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20217 return (PARSER_OK
);
20220 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20222 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20224 u32
*digest
= (u32
*) hash_buf
->digest
;
20226 salt_t
*salt
= hash_buf
->salt
;
20232 char *hash_pos
= input_buf
+ 64;
20233 char *salt1_pos
= input_buf
+ 128;
20234 char *salt2_pos
= input_buf
;
20240 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20241 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20242 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20243 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20245 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20246 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20247 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20248 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20250 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20251 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20252 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20253 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20255 salt
->salt_len
= 48;
20257 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20263 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20264 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20265 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20266 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20267 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20268 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20269 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20270 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20272 return (PARSER_OK
);
20275 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20277 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20279 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20280 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20282 u32
*digest
= (u32
*) hash_buf
->digest
;
20284 salt_t
*salt
= hash_buf
->salt
;
20286 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20292 char *param0_pos
= input_buf
+ 6 + 1;
20294 char *param1_pos
= strchr (param0_pos
, '*');
20296 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20298 u32 param0_len
= param1_pos
- param0_pos
;
20302 char *param2_pos
= strchr (param1_pos
, '*');
20304 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20306 u32 param1_len
= param2_pos
- param1_pos
;
20310 char *param3_pos
= strchr (param2_pos
, '*');
20312 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20314 u32 param2_len
= param3_pos
- param2_pos
;
20318 char *param4_pos
= strchr (param3_pos
, '*');
20320 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20322 u32 param3_len
= param4_pos
- param3_pos
;
20326 char *param5_pos
= strchr (param4_pos
, '*');
20328 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20330 u32 param4_len
= param5_pos
- param4_pos
;
20334 char *param6_pos
= strchr (param5_pos
, '*');
20336 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20338 u32 param5_len
= param6_pos
- param5_pos
;
20342 char *param7_pos
= strchr (param6_pos
, '*');
20344 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20346 u32 param6_len
= param7_pos
- param6_pos
;
20350 char *param8_pos
= strchr (param7_pos
, '*');
20352 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20354 u32 param7_len
= param8_pos
- param7_pos
;
20358 const uint type
= atoi (param0_pos
);
20359 const uint mode
= atoi (param1_pos
);
20360 const uint magic
= atoi (param2_pos
);
20362 char *salt_buf
= param3_pos
;
20364 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20366 const uint compress_length
= atoi (param5_pos
);
20368 char *data_buf
= param6_pos
;
20369 char *auth
= param7_pos
;
20375 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20377 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20379 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20381 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20383 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20385 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20387 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20389 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20391 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20393 if (type
!= 0) return (PARSER_SALT_VALUE
);
20395 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20397 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20399 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20407 zip2
->magic
= magic
;
20411 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20412 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20413 zip2
->salt_buf
[2] = 0;
20414 zip2
->salt_buf
[3] = 0;
20416 zip2
->salt_len
= 8;
20418 else if (mode
== 2)
20420 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20421 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20422 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20423 zip2
->salt_buf
[3] = 0;
20425 zip2
->salt_len
= 12;
20427 else if (mode
== 3)
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] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20432 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20434 zip2
->salt_len
= 16;
20437 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20438 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20439 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20440 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20442 zip2
->verify_bytes
= verify_bytes
;
20444 zip2
->compress_length
= compress_length
;
20446 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20448 for (uint i
= 0; i
< param6_len
; i
+= 2)
20450 const char p0
= data_buf
[i
+ 0];
20451 const char p1
= data_buf
[i
+ 1];
20453 *data_buf_ptr
++ = hex_convert (p1
) << 0
20454 | hex_convert (p0
) << 4;
20459 *data_buf_ptr
= 0x80;
20461 char *auth_ptr
= (char *) zip2
->auth_buf
;
20463 for (uint i
= 0; i
< param7_len
; i
+= 2)
20465 const char p0
= auth
[i
+ 0];
20466 const char p1
= auth
[i
+ 1];
20468 *auth_ptr
++ = hex_convert (p1
) << 0
20469 | hex_convert (p0
) << 4;
20478 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20479 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20480 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20481 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20482 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20483 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20484 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20485 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20487 salt
->salt_len
= 32;
20489 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20492 * digest buf (fake)
20495 digest
[0] = zip2
->auth_buf
[0];
20496 digest
[1] = zip2
->auth_buf
[1];
20497 digest
[2] = zip2
->auth_buf
[2];
20498 digest
[3] = zip2
->auth_buf
[3];
20500 return (PARSER_OK
);
20504 * parallel running threads
20509 BOOL WINAPI
sigHandler_default (DWORD sig
)
20513 case CTRL_CLOSE_EVENT
:
20516 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20517 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20518 * function otherwise it is too late (e.g. after returning from this function)
20523 SetConsoleCtrlHandler (NULL
, TRUE
);
20530 case CTRL_LOGOFF_EVENT
:
20531 case CTRL_SHUTDOWN_EVENT
:
20535 SetConsoleCtrlHandler (NULL
, TRUE
);
20543 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20547 case CTRL_CLOSE_EVENT
:
20551 SetConsoleCtrlHandler (NULL
, TRUE
);
20558 case CTRL_LOGOFF_EVENT
:
20559 case CTRL_SHUTDOWN_EVENT
:
20563 SetConsoleCtrlHandler (NULL
, TRUE
);
20571 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20573 if (callback
== NULL
)
20575 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20579 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20585 void sigHandler_default (int sig
)
20589 signal (sig
, NULL
);
20592 void sigHandler_benchmark (int sig
)
20596 signal (sig
, NULL
);
20599 void hc_signal (void (callback
) (int))
20601 if (callback
== NULL
) callback
= SIG_DFL
;
20603 signal (SIGINT
, callback
);
20604 signal (SIGTERM
, callback
);
20605 signal (SIGABRT
, callback
);
20610 void status_display ();
20612 void *thread_keypress (void *p
)
20614 int benchmark
= *((int *) p
);
20616 uint quiet
= data
.quiet
;
20620 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20622 int ch
= tty_getchar();
20624 if (ch
== -1) break;
20626 if (ch
== 0) continue;
20628 //https://github.com/hashcat/hashcat/issues/302
20633 hc_thread_mutex_lock (mux_display
);
20649 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20650 if (quiet
== 0) fflush (stdout
);
20662 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20663 if (quiet
== 0) fflush (stdout
);
20675 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20676 if (quiet
== 0) fflush (stdout
);
20688 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20689 if (quiet
== 0) fflush (stdout
);
20697 if (benchmark
== 1) break;
20699 stop_at_checkpoint ();
20703 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20704 if (quiet
== 0) fflush (stdout
);
20712 if (benchmark
== 1)
20724 //https://github.com/hashcat/hashcat/issues/302
20729 hc_thread_mutex_unlock (mux_display
);
20741 bool class_num (const u8 c
)
20743 return ((c
>= '0') && (c
<= '9'));
20746 bool class_lower (const u8 c
)
20748 return ((c
>= 'a') && (c
<= 'z'));
20751 bool class_upper (const u8 c
)
20753 return ((c
>= 'A') && (c
<= 'Z'));
20756 bool class_alpha (const u8 c
)
20758 return (class_lower (c
) || class_upper (c
));
20761 int conv_ctoi (const u8 c
)
20767 else if (class_upper (c
))
20769 return c
- 'A' + 10;
20775 int conv_itoc (const u8 c
)
20783 return c
+ 'A' - 10;
20793 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20794 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20795 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20796 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20797 #define MAX_KERNEL_RULES 255
20798 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20799 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20800 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20802 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20803 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20804 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20805 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20807 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20812 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20814 switch (rule_buf
[rule_pos
])
20820 case RULE_OP_MANGLE_NOOP
:
20821 SET_NAME (rule
, rule_buf
[rule_pos
]);
20824 case RULE_OP_MANGLE_LREST
:
20825 SET_NAME (rule
, rule_buf
[rule_pos
]);
20828 case RULE_OP_MANGLE_UREST
:
20829 SET_NAME (rule
, rule_buf
[rule_pos
]);
20832 case RULE_OP_MANGLE_LREST_UFIRST
:
20833 SET_NAME (rule
, rule_buf
[rule_pos
]);
20836 case RULE_OP_MANGLE_UREST_LFIRST
:
20837 SET_NAME (rule
, rule_buf
[rule_pos
]);
20840 case RULE_OP_MANGLE_TREST
:
20841 SET_NAME (rule
, rule_buf
[rule_pos
]);
20844 case RULE_OP_MANGLE_TOGGLE_AT
:
20845 SET_NAME (rule
, rule_buf
[rule_pos
]);
20846 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20849 case RULE_OP_MANGLE_REVERSE
:
20850 SET_NAME (rule
, rule_buf
[rule_pos
]);
20853 case RULE_OP_MANGLE_DUPEWORD
:
20854 SET_NAME (rule
, rule_buf
[rule_pos
]);
20857 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20858 SET_NAME (rule
, rule_buf
[rule_pos
]);
20859 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20862 case RULE_OP_MANGLE_REFLECT
:
20863 SET_NAME (rule
, rule_buf
[rule_pos
]);
20866 case RULE_OP_MANGLE_ROTATE_LEFT
:
20867 SET_NAME (rule
, rule_buf
[rule_pos
]);
20870 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20871 SET_NAME (rule
, rule_buf
[rule_pos
]);
20874 case RULE_OP_MANGLE_APPEND
:
20875 SET_NAME (rule
, rule_buf
[rule_pos
]);
20876 SET_P0 (rule
, rule_buf
[rule_pos
]);
20879 case RULE_OP_MANGLE_PREPEND
:
20880 SET_NAME (rule
, rule_buf
[rule_pos
]);
20881 SET_P0 (rule
, rule_buf
[rule_pos
]);
20884 case RULE_OP_MANGLE_DELETE_FIRST
:
20885 SET_NAME (rule
, rule_buf
[rule_pos
]);
20888 case RULE_OP_MANGLE_DELETE_LAST
:
20889 SET_NAME (rule
, rule_buf
[rule_pos
]);
20892 case RULE_OP_MANGLE_DELETE_AT
:
20893 SET_NAME (rule
, rule_buf
[rule_pos
]);
20894 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20897 case RULE_OP_MANGLE_EXTRACT
:
20898 SET_NAME (rule
, rule_buf
[rule_pos
]);
20899 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20900 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20903 case RULE_OP_MANGLE_OMIT
:
20904 SET_NAME (rule
, rule_buf
[rule_pos
]);
20905 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20906 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20909 case RULE_OP_MANGLE_INSERT
:
20910 SET_NAME (rule
, rule_buf
[rule_pos
]);
20911 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20912 SET_P1 (rule
, rule_buf
[rule_pos
]);
20915 case RULE_OP_MANGLE_OVERSTRIKE
:
20916 SET_NAME (rule
, rule_buf
[rule_pos
]);
20917 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20918 SET_P1 (rule
, rule_buf
[rule_pos
]);
20921 case RULE_OP_MANGLE_TRUNCATE_AT
:
20922 SET_NAME (rule
, rule_buf
[rule_pos
]);
20923 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20926 case RULE_OP_MANGLE_REPLACE
:
20927 SET_NAME (rule
, rule_buf
[rule_pos
]);
20928 SET_P0 (rule
, rule_buf
[rule_pos
]);
20929 SET_P1 (rule
, rule_buf
[rule_pos
]);
20932 case RULE_OP_MANGLE_PURGECHAR
:
20936 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20940 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20941 SET_NAME (rule
, rule_buf
[rule_pos
]);
20942 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20945 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20946 SET_NAME (rule
, rule_buf
[rule_pos
]);
20947 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20950 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20951 SET_NAME (rule
, rule_buf
[rule_pos
]);
20954 case RULE_OP_MANGLE_SWITCH_FIRST
:
20955 SET_NAME (rule
, rule_buf
[rule_pos
]);
20958 case RULE_OP_MANGLE_SWITCH_LAST
:
20959 SET_NAME (rule
, rule_buf
[rule_pos
]);
20962 case RULE_OP_MANGLE_SWITCH_AT
:
20963 SET_NAME (rule
, rule_buf
[rule_pos
]);
20964 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20965 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20968 case RULE_OP_MANGLE_CHR_SHIFTL
:
20969 SET_NAME (rule
, rule_buf
[rule_pos
]);
20970 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20973 case RULE_OP_MANGLE_CHR_SHIFTR
:
20974 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20978 case RULE_OP_MANGLE_CHR_INCR
:
20979 SET_NAME (rule
, rule_buf
[rule_pos
]);
20980 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20983 case RULE_OP_MANGLE_CHR_DECR
:
20984 SET_NAME (rule
, rule_buf
[rule_pos
]);
20985 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20988 case RULE_OP_MANGLE_REPLACE_NP1
:
20989 SET_NAME (rule
, rule_buf
[rule_pos
]);
20990 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20993 case RULE_OP_MANGLE_REPLACE_NM1
:
20994 SET_NAME (rule
, rule_buf
[rule_pos
]);
20995 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20998 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20999 SET_NAME (rule
, rule_buf
[rule_pos
]);
21000 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21003 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21004 SET_NAME (rule
, rule_buf
[rule_pos
]);
21005 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21008 case RULE_OP_MANGLE_TITLE
:
21009 SET_NAME (rule
, rule_buf
[rule_pos
]);
21018 if (rule_pos
< rule_len
) return (-1);
21023 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21027 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21031 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21035 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21039 case RULE_OP_MANGLE_NOOP
:
21040 rule_buf
[rule_pos
] = rule_cmd
;
21043 case RULE_OP_MANGLE_LREST
:
21044 rule_buf
[rule_pos
] = rule_cmd
;
21047 case RULE_OP_MANGLE_UREST
:
21048 rule_buf
[rule_pos
] = rule_cmd
;
21051 case RULE_OP_MANGLE_LREST_UFIRST
:
21052 rule_buf
[rule_pos
] = rule_cmd
;
21055 case RULE_OP_MANGLE_UREST_LFIRST
:
21056 rule_buf
[rule_pos
] = rule_cmd
;
21059 case RULE_OP_MANGLE_TREST
:
21060 rule_buf
[rule_pos
] = rule_cmd
;
21063 case RULE_OP_MANGLE_TOGGLE_AT
:
21064 rule_buf
[rule_pos
] = rule_cmd
;
21065 GET_P0_CONV (rule
);
21068 case RULE_OP_MANGLE_REVERSE
:
21069 rule_buf
[rule_pos
] = rule_cmd
;
21072 case RULE_OP_MANGLE_DUPEWORD
:
21073 rule_buf
[rule_pos
] = rule_cmd
;
21076 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21077 rule_buf
[rule_pos
] = rule_cmd
;
21078 GET_P0_CONV (rule
);
21081 case RULE_OP_MANGLE_REFLECT
:
21082 rule_buf
[rule_pos
] = rule_cmd
;
21085 case RULE_OP_MANGLE_ROTATE_LEFT
:
21086 rule_buf
[rule_pos
] = rule_cmd
;
21089 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21090 rule_buf
[rule_pos
] = rule_cmd
;
21093 case RULE_OP_MANGLE_APPEND
:
21094 rule_buf
[rule_pos
] = rule_cmd
;
21098 case RULE_OP_MANGLE_PREPEND
:
21099 rule_buf
[rule_pos
] = rule_cmd
;
21103 case RULE_OP_MANGLE_DELETE_FIRST
:
21104 rule_buf
[rule_pos
] = rule_cmd
;
21107 case RULE_OP_MANGLE_DELETE_LAST
:
21108 rule_buf
[rule_pos
] = rule_cmd
;
21111 case RULE_OP_MANGLE_DELETE_AT
:
21112 rule_buf
[rule_pos
] = rule_cmd
;
21113 GET_P0_CONV (rule
);
21116 case RULE_OP_MANGLE_EXTRACT
:
21117 rule_buf
[rule_pos
] = rule_cmd
;
21118 GET_P0_CONV (rule
);
21119 GET_P1_CONV (rule
);
21122 case RULE_OP_MANGLE_OMIT
:
21123 rule_buf
[rule_pos
] = rule_cmd
;
21124 GET_P0_CONV (rule
);
21125 GET_P1_CONV (rule
);
21128 case RULE_OP_MANGLE_INSERT
:
21129 rule_buf
[rule_pos
] = rule_cmd
;
21130 GET_P0_CONV (rule
);
21134 case RULE_OP_MANGLE_OVERSTRIKE
:
21135 rule_buf
[rule_pos
] = rule_cmd
;
21136 GET_P0_CONV (rule
);
21140 case RULE_OP_MANGLE_TRUNCATE_AT
:
21141 rule_buf
[rule_pos
] = rule_cmd
;
21142 GET_P0_CONV (rule
);
21145 case RULE_OP_MANGLE_REPLACE
:
21146 rule_buf
[rule_pos
] = rule_cmd
;
21151 case RULE_OP_MANGLE_PURGECHAR
:
21155 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21159 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21160 rule_buf
[rule_pos
] = rule_cmd
;
21161 GET_P0_CONV (rule
);
21164 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21165 rule_buf
[rule_pos
] = rule_cmd
;
21166 GET_P0_CONV (rule
);
21169 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21170 rule_buf
[rule_pos
] = rule_cmd
;
21173 case RULE_OP_MANGLE_SWITCH_FIRST
:
21174 rule_buf
[rule_pos
] = rule_cmd
;
21177 case RULE_OP_MANGLE_SWITCH_LAST
:
21178 rule_buf
[rule_pos
] = rule_cmd
;
21181 case RULE_OP_MANGLE_SWITCH_AT
:
21182 rule_buf
[rule_pos
] = rule_cmd
;
21183 GET_P0_CONV (rule
);
21184 GET_P1_CONV (rule
);
21187 case RULE_OP_MANGLE_CHR_SHIFTL
:
21188 rule_buf
[rule_pos
] = rule_cmd
;
21189 GET_P0_CONV (rule
);
21192 case RULE_OP_MANGLE_CHR_SHIFTR
:
21193 rule_buf
[rule_pos
] = rule_cmd
;
21194 GET_P0_CONV (rule
);
21197 case RULE_OP_MANGLE_CHR_INCR
:
21198 rule_buf
[rule_pos
] = rule_cmd
;
21199 GET_P0_CONV (rule
);
21202 case RULE_OP_MANGLE_CHR_DECR
:
21203 rule_buf
[rule_pos
] = rule_cmd
;
21204 GET_P0_CONV (rule
);
21207 case RULE_OP_MANGLE_REPLACE_NP1
:
21208 rule_buf
[rule_pos
] = rule_cmd
;
21209 GET_P0_CONV (rule
);
21212 case RULE_OP_MANGLE_REPLACE_NM1
:
21213 rule_buf
[rule_pos
] = rule_cmd
;
21214 GET_P0_CONV (rule
);
21217 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21218 rule_buf
[rule_pos
] = rule_cmd
;
21219 GET_P0_CONV (rule
);
21222 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21223 rule_buf
[rule_pos
] = rule_cmd
;
21224 GET_P0_CONV (rule
);
21227 case RULE_OP_MANGLE_TITLE
:
21228 rule_buf
[rule_pos
] = rule_cmd
;
21232 return rule_pos
- 1;
21250 * CPU rules : this is from hashcat sources, cpu based rules
21253 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21254 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21256 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21257 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21258 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21260 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21261 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21262 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21264 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21268 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21273 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21277 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21282 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21286 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21291 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21296 for (l
= 0; l
< arr_len
; l
++)
21298 r
= arr_len
- 1 - l
;
21302 MANGLE_SWITCH (arr
, l
, r
);
21308 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21310 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21312 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21314 return (arr_len
* 2);
21317 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21319 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21321 int orig_len
= arr_len
;
21325 for (i
= 0; i
< times
; i
++)
21327 memcpy (&arr
[arr_len
], arr
, orig_len
);
21329 arr_len
+= orig_len
;
21335 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21337 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21339 mangle_double (arr
, arr_len
);
21341 mangle_reverse (arr
+ arr_len
, arr_len
);
21343 return (arr_len
* 2);
21346 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21351 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21353 MANGLE_SWITCH (arr
, l
, r
);
21359 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21364 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21366 MANGLE_SWITCH (arr
, l
, r
);
21372 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21374 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21378 return (arr_len
+ 1);
21381 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21383 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21387 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21389 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21394 return (arr_len
+ 1);
21397 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21399 if (upos
>= arr_len
) return (arr_len
);
21403 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21405 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21408 return (arr_len
- 1);
21411 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21413 if (upos
>= arr_len
) return (arr_len
);
21415 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21419 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21421 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21427 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21429 if (upos
>= arr_len
) return (arr_len
);
21431 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21435 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21437 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21440 return (arr_len
- ulen
);
21443 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21445 if (upos
>= arr_len
) return (arr_len
);
21447 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21451 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21453 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21458 return (arr_len
+ 1);
21461 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
)
21463 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21465 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21467 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21469 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21471 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21473 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21475 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21477 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21479 return (arr_len
+ arr2_cpy
);
21482 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21484 if (upos
>= arr_len
) return (arr_len
);
21491 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21493 if (upos
>= arr_len
) return (arr_len
);
21495 memset (arr
+ upos
, 0, arr_len
- upos
);
21500 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21504 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21506 if (arr
[arr_pos
] != oldc
) continue;
21508 arr
[arr_pos
] = newc
;
21514 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21520 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21522 if (arr
[arr_pos
] == c
) continue;
21524 arr
[ret_len
] = arr
[arr_pos
];
21532 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21534 if (ulen
> arr_len
) return (arr_len
);
21536 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21538 char cs
[100] = { 0 };
21540 memcpy (cs
, arr
, ulen
);
21544 for (i
= 0; i
< ulen
; i
++)
21548 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21554 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21556 if (ulen
> arr_len
) return (arr_len
);
21558 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21560 int upos
= arr_len
- ulen
;
21564 for (i
= 0; i
< ulen
; i
++)
21566 char c
= arr
[upos
+ i
];
21568 arr_len
= mangle_append (arr
, arr_len
, c
);
21574 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21576 if ( arr_len
== 0) return (arr_len
);
21577 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21579 char c
= arr
[upos
];
21583 for (i
= 0; i
< ulen
; i
++)
21585 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21591 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21593 if ( arr_len
== 0) return (arr_len
);
21594 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21598 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21600 int new_pos
= arr_pos
* 2;
21602 arr
[new_pos
] = arr
[arr_pos
];
21604 arr
[new_pos
+ 1] = arr
[arr_pos
];
21607 return (arr_len
* 2);
21610 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21612 if (upos
>= arr_len
) return (arr_len
);
21613 if (upos2
>= arr_len
) return (arr_len
);
21615 MANGLE_SWITCH (arr
, upos
, upos2
);
21620 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21622 MANGLE_SWITCH (arr
, upos
, upos2
);
21627 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21629 if (upos
>= arr_len
) return (arr_len
);
21636 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21638 if (upos
>= arr_len
) return (arr_len
);
21645 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21647 if (upos
>= arr_len
) return (arr_len
);
21654 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21656 if (upos
>= arr_len
) return (arr_len
);
21663 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21665 int upper_next
= 1;
21669 for (pos
= 0; pos
< arr_len
; pos
++)
21671 if (arr
[pos
] == ' ')
21682 MANGLE_UPPER_AT (arr
, pos
);
21686 MANGLE_LOWER_AT (arr
, pos
);
21693 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21695 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21701 for (j
= 0; j
< rp_gen_num
; j
++)
21708 switch ((char) get_random_num (0, 9))
21711 r
= get_random_num (0, sizeof (grp_op_nop
));
21712 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21716 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21717 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21718 p1
= get_random_num (0, sizeof (grp_pos
));
21719 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21723 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21724 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21725 p1
= get_random_num (1, 6);
21726 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21730 r
= get_random_num (0, sizeof (grp_op_chr
));
21731 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21732 p1
= get_random_num (0x20, 0x7e);
21733 rule_buf
[rule_pos
++] = (char) p1
;
21737 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21738 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21739 p1
= get_random_num (0x20, 0x7e);
21740 rule_buf
[rule_pos
++] = (char) p1
;
21741 p2
= get_random_num (0x20, 0x7e);
21743 p2
= get_random_num (0x20, 0x7e);
21744 rule_buf
[rule_pos
++] = (char) p2
;
21748 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21749 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21750 p1
= get_random_num (0, sizeof (grp_pos
));
21751 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21752 p2
= get_random_num (0x20, 0x7e);
21753 rule_buf
[rule_pos
++] = (char) p2
;
21757 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21758 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21759 p1
= get_random_num (0, sizeof (grp_pos
));
21760 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21761 p2
= get_random_num (0, sizeof (grp_pos
));
21763 p2
= get_random_num (0, sizeof (grp_pos
));
21764 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21768 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21769 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21770 p1
= get_random_num (0, sizeof (grp_pos
));
21771 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21772 p2
= get_random_num (1, sizeof (grp_pos
));
21774 p2
= get_random_num (1, sizeof (grp_pos
));
21775 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21779 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21780 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21781 p1
= get_random_num (0, sizeof (grp_pos
));
21782 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21783 p2
= get_random_num (1, sizeof (grp_pos
));
21784 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21785 p3
= get_random_num (0, sizeof (grp_pos
));
21786 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21794 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21796 char mem
[BLOCK_SIZE
] = { 0 };
21798 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21800 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21802 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21804 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21806 int out_len
= in_len
;
21807 int mem_len
= in_len
;
21809 memcpy (out
, in
, out_len
);
21813 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21818 switch (rule
[rule_pos
])
21823 case RULE_OP_MANGLE_NOOP
:
21826 case RULE_OP_MANGLE_LREST
:
21827 out_len
= mangle_lrest (out
, out_len
);
21830 case RULE_OP_MANGLE_UREST
:
21831 out_len
= mangle_urest (out
, out_len
);
21834 case RULE_OP_MANGLE_LREST_UFIRST
:
21835 out_len
= mangle_lrest (out
, out_len
);
21836 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21839 case RULE_OP_MANGLE_UREST_LFIRST
:
21840 out_len
= mangle_urest (out
, out_len
);
21841 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21844 case RULE_OP_MANGLE_TREST
:
21845 out_len
= mangle_trest (out
, out_len
);
21848 case RULE_OP_MANGLE_TOGGLE_AT
:
21849 NEXT_RULEPOS (rule_pos
);
21850 NEXT_RPTOI (rule
, rule_pos
, upos
);
21851 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21854 case RULE_OP_MANGLE_REVERSE
:
21855 out_len
= mangle_reverse (out
, out_len
);
21858 case RULE_OP_MANGLE_DUPEWORD
:
21859 out_len
= mangle_double (out
, out_len
);
21862 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21863 NEXT_RULEPOS (rule_pos
);
21864 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21865 out_len
= mangle_double_times (out
, out_len
, ulen
);
21868 case RULE_OP_MANGLE_REFLECT
:
21869 out_len
= mangle_reflect (out
, out_len
);
21872 case RULE_OP_MANGLE_ROTATE_LEFT
:
21873 mangle_rotate_left (out
, out_len
);
21876 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21877 mangle_rotate_right (out
, out_len
);
21880 case RULE_OP_MANGLE_APPEND
:
21881 NEXT_RULEPOS (rule_pos
);
21882 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21885 case RULE_OP_MANGLE_PREPEND
:
21886 NEXT_RULEPOS (rule_pos
);
21887 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21890 case RULE_OP_MANGLE_DELETE_FIRST
:
21891 out_len
= mangle_delete_at (out
, out_len
, 0);
21894 case RULE_OP_MANGLE_DELETE_LAST
:
21895 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21898 case RULE_OP_MANGLE_DELETE_AT
:
21899 NEXT_RULEPOS (rule_pos
);
21900 NEXT_RPTOI (rule
, rule_pos
, upos
);
21901 out_len
= mangle_delete_at (out
, out_len
, upos
);
21904 case RULE_OP_MANGLE_EXTRACT
:
21905 NEXT_RULEPOS (rule_pos
);
21906 NEXT_RPTOI (rule
, rule_pos
, upos
);
21907 NEXT_RULEPOS (rule_pos
);
21908 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21909 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21912 case RULE_OP_MANGLE_OMIT
:
21913 NEXT_RULEPOS (rule_pos
);
21914 NEXT_RPTOI (rule
, rule_pos
, upos
);
21915 NEXT_RULEPOS (rule_pos
);
21916 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21917 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21920 case RULE_OP_MANGLE_INSERT
:
21921 NEXT_RULEPOS (rule_pos
);
21922 NEXT_RPTOI (rule
, rule_pos
, upos
);
21923 NEXT_RULEPOS (rule_pos
);
21924 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21927 case RULE_OP_MANGLE_OVERSTRIKE
:
21928 NEXT_RULEPOS (rule_pos
);
21929 NEXT_RPTOI (rule
, rule_pos
, upos
);
21930 NEXT_RULEPOS (rule_pos
);
21931 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21934 case RULE_OP_MANGLE_TRUNCATE_AT
:
21935 NEXT_RULEPOS (rule_pos
);
21936 NEXT_RPTOI (rule
, rule_pos
, upos
);
21937 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21940 case RULE_OP_MANGLE_REPLACE
:
21941 NEXT_RULEPOS (rule_pos
);
21942 NEXT_RULEPOS (rule_pos
);
21943 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21946 case RULE_OP_MANGLE_PURGECHAR
:
21947 NEXT_RULEPOS (rule_pos
);
21948 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21951 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21955 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21956 NEXT_RULEPOS (rule_pos
);
21957 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21958 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21961 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21962 NEXT_RULEPOS (rule_pos
);
21963 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21964 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21967 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21968 out_len
= mangle_dupechar (out
, out_len
);
21971 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21972 NEXT_RULEPOS (rule_pos
);
21973 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21974 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21977 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21978 NEXT_RULEPOS (rule_pos
);
21979 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21980 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21983 case RULE_OP_MANGLE_SWITCH_FIRST
:
21984 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21987 case RULE_OP_MANGLE_SWITCH_LAST
:
21988 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21991 case RULE_OP_MANGLE_SWITCH_AT
:
21992 NEXT_RULEPOS (rule_pos
);
21993 NEXT_RPTOI (rule
, rule_pos
, upos
);
21994 NEXT_RULEPOS (rule_pos
);
21995 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21996 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21999 case RULE_OP_MANGLE_CHR_SHIFTL
:
22000 NEXT_RULEPOS (rule_pos
);
22001 NEXT_RPTOI (rule
, rule_pos
, upos
);
22002 mangle_chr_shiftl (out
, out_len
, upos
);
22005 case RULE_OP_MANGLE_CHR_SHIFTR
:
22006 NEXT_RULEPOS (rule_pos
);
22007 NEXT_RPTOI (rule
, rule_pos
, upos
);
22008 mangle_chr_shiftr (out
, out_len
, upos
);
22011 case RULE_OP_MANGLE_CHR_INCR
:
22012 NEXT_RULEPOS (rule_pos
);
22013 NEXT_RPTOI (rule
, rule_pos
, upos
);
22014 mangle_chr_incr (out
, out_len
, upos
);
22017 case RULE_OP_MANGLE_CHR_DECR
:
22018 NEXT_RULEPOS (rule_pos
);
22019 NEXT_RPTOI (rule
, rule_pos
, upos
);
22020 mangle_chr_decr (out
, out_len
, upos
);
22023 case RULE_OP_MANGLE_REPLACE_NP1
:
22024 NEXT_RULEPOS (rule_pos
);
22025 NEXT_RPTOI (rule
, rule_pos
, upos
);
22026 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22029 case RULE_OP_MANGLE_REPLACE_NM1
:
22030 NEXT_RULEPOS (rule_pos
);
22031 NEXT_RPTOI (rule
, rule_pos
, upos
);
22032 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22035 case RULE_OP_MANGLE_TITLE
:
22036 out_len
= mangle_title (out
, out_len
);
22039 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22040 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22041 NEXT_RULEPOS (rule_pos
);
22042 NEXT_RPTOI (rule
, rule_pos
, upos
);
22043 NEXT_RULEPOS (rule_pos
);
22044 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22045 NEXT_RULEPOS (rule_pos
);
22046 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22047 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22050 case RULE_OP_MANGLE_APPEND_MEMORY
:
22051 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22052 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22053 memcpy (out
+ out_len
, mem
, mem_len
);
22054 out_len
+= mem_len
;
22057 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22058 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22059 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22060 memcpy (mem
+ mem_len
, out
, out_len
);
22061 out_len
+= mem_len
;
22062 memcpy (out
, mem
, out_len
);
22065 case RULE_OP_MEMORIZE_WORD
:
22066 memcpy (mem
, out
, out_len
);
22070 case RULE_OP_REJECT_LESS
:
22071 NEXT_RULEPOS (rule_pos
);
22072 NEXT_RPTOI (rule
, rule_pos
, upos
);
22073 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22076 case RULE_OP_REJECT_GREATER
:
22077 NEXT_RULEPOS (rule_pos
);
22078 NEXT_RPTOI (rule
, rule_pos
, upos
);
22079 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22082 case RULE_OP_REJECT_CONTAIN
:
22083 NEXT_RULEPOS (rule_pos
);
22084 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22087 case RULE_OP_REJECT_NOT_CONTAIN
:
22088 NEXT_RULEPOS (rule_pos
);
22089 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22092 case RULE_OP_REJECT_EQUAL_FIRST
:
22093 NEXT_RULEPOS (rule_pos
);
22094 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22097 case RULE_OP_REJECT_EQUAL_LAST
:
22098 NEXT_RULEPOS (rule_pos
);
22099 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22102 case RULE_OP_REJECT_EQUAL_AT
:
22103 NEXT_RULEPOS (rule_pos
);
22104 NEXT_RPTOI (rule
, rule_pos
, upos
);
22105 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22106 NEXT_RULEPOS (rule_pos
);
22107 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22110 case RULE_OP_REJECT_CONTAINS
:
22111 NEXT_RULEPOS (rule_pos
);
22112 NEXT_RPTOI (rule
, rule_pos
, upos
);
22113 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22114 NEXT_RULEPOS (rule_pos
);
22115 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22116 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22119 case RULE_OP_REJECT_MEMORY
:
22120 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22124 return (RULE_RC_SYNTAX_ERROR
);
22129 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);