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 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
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 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
);
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 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
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 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
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 hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &currLinkWidth
);
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 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
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 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
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 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
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 hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &clocksThrottleReasons
);
3380 hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &supportedThrottleReasons
);
3382 clocksThrottleReasons
&= supportedThrottleReasons
;
3384 return (clocksThrottleReasons
> 0);
3390 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3392 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3396 if (data
.hm_device
[device_id
].od_version
== 5)
3398 ADLFanSpeedValue lpFanSpeedValue
;
3400 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3402 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3403 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3404 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3405 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3407 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3411 else // od_version == 6
3413 ADLOD6FanSpeedValue fan_speed_value
;
3415 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3417 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3418 fan_speed_value
.iFanSpeed
= fanspeed
;
3420 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3430 int hm_set_fanspeed_with_device_id_nvml (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3432 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3436 // NVML does not support setting the fan speed... :((
3438 if (fanspeed
== fanpolicy
) return -1; // makes the compiler happy
3445 #endif // HAVE_HWMON
3451 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3453 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3455 if (css_cnt
> SP_PW_MAX
)
3457 log_error ("ERROR: mask length is too long");
3462 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3464 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3466 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3467 uint cs_len
= css
[css_pos
].cs_len
;
3469 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3471 uint c
= cs_buf
[cs_pos
] & 0xff;
3478 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3480 cs_t
*cs
= &css
[css_cnt
];
3482 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3484 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3488 for (i
= 0; i
< cs
->cs_len
; i
++)
3490 const uint u
= cs
->cs_buf
[i
];
3495 for (i
= 0; i
< in_len
; i
++)
3497 uint u
= in_buf
[i
] & 0xff;
3499 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3501 if (css_uniq
[u
] == 1) continue;
3505 cs
->cs_buf
[cs
->cs_len
] = u
;
3513 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3517 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3519 uint p0
= in_buf
[in_pos
] & 0xff;
3521 if (interpret
== 1 && p0
== '?')
3525 if (in_pos
== in_len
) break;
3527 uint p1
= in_buf
[in_pos
] & 0xff;
3531 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3533 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3535 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3537 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3539 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3541 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3543 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3544 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3546 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3547 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3549 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3550 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3552 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3553 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3555 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3557 default: log_error ("Syntax error: %s", in_buf
);
3563 if (data
.hex_charset
)
3567 if (in_pos
== in_len
)
3569 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3574 uint p1
= in_buf
[in_pos
] & 0xff;
3576 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3578 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3585 chr
= hex_convert (p1
) << 0;
3586 chr
|= hex_convert (p0
) << 4;
3588 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3594 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3600 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3604 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3606 sum
*= css
[css_pos
].cs_len
;
3612 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3614 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3619 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3621 char p0
= mask_buf
[mask_pos
];
3627 if (mask_pos
== mask_len
) break;
3629 char p1
= mask_buf
[mask_pos
];
3635 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3637 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3639 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3641 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3643 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3645 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3647 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3648 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3650 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3651 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3653 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3654 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3656 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3657 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3659 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3661 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3667 if (data
.hex_charset
)
3671 // if there is no 2nd hex character, show an error:
3673 if (mask_pos
== mask_len
)
3675 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3680 char p1
= mask_buf
[mask_pos
];
3682 // if they are not valid hex character, show an error:
3684 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3686 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3693 chr
|= hex_convert (p1
) << 0;
3694 chr
|= hex_convert (p0
) << 4;
3696 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3702 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3709 log_error ("ERROR: invalid mask length (0)");
3719 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3721 for (int i
= 0; i
< css_cnt
; i
++)
3723 uint len
= css
[i
].cs_len
;
3724 u64 next
= val
/ len
;
3725 uint pos
= val
% len
;
3726 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3731 void mp_cut_at (char *mask
, uint max
)
3735 uint mask_len
= strlen (mask
);
3737 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3739 if (mask
[i
] == '?') i
++;
3745 void mp_setup_sys (cs_t
*mp_sys
)
3749 uint donec
[CHARSIZ
] = { 0 };
3751 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3752 mp_sys
[0].cs_buf
[pos
++] = chr
;
3753 mp_sys
[0].cs_len
= pos
; }
3755 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3756 mp_sys
[1].cs_buf
[pos
++] = chr
;
3757 mp_sys
[1].cs_len
= pos
; }
3759 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3760 mp_sys
[2].cs_buf
[pos
++] = chr
;
3761 mp_sys
[2].cs_len
= pos
; }
3763 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3764 mp_sys
[3].cs_buf
[pos
++] = chr
;
3765 mp_sys
[3].cs_len
= pos
; }
3767 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3768 mp_sys
[4].cs_len
= pos
; }
3770 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3771 mp_sys
[5].cs_len
= pos
; }
3774 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3776 FILE *fp
= fopen (buf
, "rb");
3778 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3780 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3784 char mp_file
[1024] = { 0 };
3786 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3790 len
= in_superchop (mp_file
);
3794 log_info ("WARNING: charset file corrupted");
3796 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3800 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3805 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3807 mp_usr
[index
].cs_len
= 0;
3809 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3812 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3814 char *new_mask_buf
= (char *) mymalloc (256);
3820 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3822 if (css_pos
== len
) break;
3824 char p0
= mask_buf
[mask_pos
];
3826 new_mask_buf
[mask_pos
] = p0
;
3832 if (mask_pos
== mask_len
) break;
3834 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3838 if (data
.hex_charset
)
3842 if (mask_pos
== mask_len
)
3844 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3849 char p1
= mask_buf
[mask_pos
];
3851 // if they are not valid hex character, show an error:
3853 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3855 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3860 new_mask_buf
[mask_pos
] = p1
;
3865 if (css_pos
== len
) return (new_mask_buf
);
3867 myfree (new_mask_buf
);
3876 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3882 for (i
= start
; i
< stop
; i
++)
3884 sum
*= root_css_buf
[i
].cs_len
;
3890 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3894 cs_t
*cs
= &root_css_buf
[start
];
3898 for (i
= start
; i
< stop
; i
++)
3900 const u64 m
= v
% cs
->cs_len
;
3901 const u64 d
= v
/ cs
->cs_len
;
3905 const uint k
= cs
->cs_buf
[m
];
3907 pw_buf
[i
- start
] = (char) k
;
3909 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3913 int sp_comp_val (const void *p1
, const void *p2
)
3915 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3916 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3918 return b2
->val
- b1
->val
;
3921 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
)
3928 * Initialize hcstats
3931 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3933 u64
*root_stats_ptr
= root_stats_buf
;
3935 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3937 for (i
= 0; i
< SP_PW_MAX
; i
++)
3939 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3941 root_stats_ptr
+= CHARSIZ
;
3944 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3946 u64
*markov_stats_ptr
= markov_stats_buf
;
3948 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3950 for (i
= 0; i
< SP_PW_MAX
; i
++)
3952 for (j
= 0; j
< CHARSIZ
; j
++)
3954 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3956 markov_stats_ptr
+= CHARSIZ
;
3966 char hcstat_tmp
[256] = { 0 };
3968 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3970 hcstat
= hcstat_tmp
;
3973 FILE *fd
= fopen (hcstat
, "rb");
3977 log_error ("%s: %s", hcstat
, strerror (errno
));
3982 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3984 log_error ("%s: Could not load data", hcstat
);
3991 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3993 log_error ("%s: Could not load data", hcstat
);
4003 * Markov modifier of hcstat_table on user request
4008 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4009 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4014 /* Add all stats to first position */
4016 for (i
= 1; i
< SP_PW_MAX
; i
++)
4018 u64
*out
= root_stats_buf_by_pos
[0];
4019 u64
*in
= root_stats_buf_by_pos
[i
];
4021 for (j
= 0; j
< CHARSIZ
; j
++)
4027 for (i
= 1; i
< SP_PW_MAX
; i
++)
4029 u64
*out
= markov_stats_buf_by_key
[0][0];
4030 u64
*in
= markov_stats_buf_by_key
[i
][0];
4032 for (j
= 0; j
< CHARSIZ
; j
++)
4034 for (k
= 0; k
< CHARSIZ
; k
++)
4041 /* copy them to all pw_positions */
4043 for (i
= 1; i
< SP_PW_MAX
; i
++)
4045 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4048 for (i
= 1; i
< SP_PW_MAX
; i
++)
4050 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4058 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4060 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4062 for (i
= 0; i
< SP_PW_MAX
; i
++)
4064 root_table_buf_by_pos
[i
] = root_table_ptr
;
4066 root_table_ptr
+= CHARSIZ
;
4069 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4071 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4073 for (i
= 0; i
< SP_PW_MAX
; i
++)
4075 for (j
= 0; j
< CHARSIZ
; j
++)
4077 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4079 markov_table_ptr
+= CHARSIZ
;
4084 * Convert hcstat to tables
4087 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4089 uint key
= i
% CHARSIZ
;
4091 root_table_buf
[i
].key
= key
;
4092 root_table_buf
[i
].val
= root_stats_buf
[i
];
4095 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4097 uint key
= i
% CHARSIZ
;
4099 markov_table_buf
[i
].key
= key
;
4100 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4103 myfree (root_stats_buf
);
4104 myfree (markov_stats_buf
);
4110 for (i
= 0; i
< SP_PW_MAX
; i
++)
4112 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4115 for (i
= 0; i
< SP_PW_MAX
; i
++)
4117 for (j
= 0; j
< CHARSIZ
; j
++)
4119 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4124 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
])
4127 * Convert tables to css
4130 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4132 uint pw_pos
= i
/ CHARSIZ
;
4134 cs_t
*cs
= &root_css_buf
[pw_pos
];
4136 if (cs
->cs_len
== threshold
) continue;
4138 uint key
= root_table_buf
[i
].key
;
4140 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4142 cs
->cs_buf
[cs
->cs_len
] = key
;
4148 * Convert table to css
4151 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4153 uint c
= i
/ CHARSIZ
;
4155 cs_t
*cs
= &markov_css_buf
[c
];
4157 if (cs
->cs_len
== threshold
) continue;
4159 uint pw_pos
= c
/ CHARSIZ
;
4161 uint key
= markov_table_buf
[i
].key
;
4163 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4165 cs
->cs_buf
[cs
->cs_len
] = key
;
4171 for (uint i = 0; i < 8; i++)
4173 for (uint j = 0x20; j < 0x80; j++)
4175 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4177 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4179 for (uint k = 0; k < 10; k++)
4181 printf (" %u\n", ptr->cs_buf[k]);
4188 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4190 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4192 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4202 for (uint j
= 1; j
< CHARSIZ
; j
++)
4212 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4214 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4216 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4218 out
+= CHARSIZ
* CHARSIZ
;
4219 in
+= CHARSIZ
* CHARSIZ
;
4221 for (uint j
= 0; j
< CHARSIZ
; j
++)
4228 for (uint k
= 1; k
< CHARSIZ
; k
++)
4240 * mixed shared functions
4243 void dump_hex (const u8
*s
, const int sz
)
4245 for (int i
= 0; i
< sz
; i
++)
4247 log_info_nn ("%02x ", s
[i
]);
4253 void usage_mini_print (const char *progname
)
4255 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4258 void usage_big_print (const char *progname
)
4260 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4263 char *get_exec_path ()
4265 int exec_path_len
= 1024;
4267 char *exec_path
= (char *) mymalloc (exec_path_len
);
4271 char tmp
[32] = { 0 };
4273 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4275 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4279 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4283 uint size
= exec_path_len
;
4285 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4287 log_error("! executable path buffer too small\n");
4292 const int len
= strlen (exec_path
);
4295 #error Your Operating System is not supported or detected
4303 char *get_install_dir (const char *progname
)
4305 char *install_dir
= mystrdup (progname
);
4306 char *last_slash
= NULL
;
4308 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4312 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4318 install_dir
[0] = '.';
4322 return (install_dir
);
4325 char *get_profile_dir (const char *homedir
)
4327 #define DOT_HASHCAT ".hashcat"
4329 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4331 char *profile_dir
= (char *) mymalloc (len
+ 1);
4333 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4338 char *get_session_dir (const char *profile_dir
)
4340 #define SESSIONS_FOLDER "sessions"
4342 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4344 char *session_dir
= (char *) mymalloc (len
+ 1);
4346 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4351 uint
count_lines (FILE *fd
)
4355 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4361 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4363 if (nread
< 1) continue;
4367 for (i
= 0; i
< nread
; i
++)
4369 if (prev
== '\n') cnt
++;
4380 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4384 FILE *fd
= fopen (filename
, "rb");
4388 log_error ("%s: %s", filename
, strerror (errno
));
4393 #define MAX_KEY_SIZE (1024 * 1024)
4395 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4397 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4403 for (int fpos
= 0; fpos
< nread
; fpos
++)
4405 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4407 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4408 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4409 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4410 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4412 if (kpos
>= 64) kpos
= 0;
4419 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4423 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4424 if (CPU_ISSET(core
, cpu_set
)) break;
4426 thread_affinity_policy_data_t policy
= { core
};
4428 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4430 if (data
.quiet
== 0)
4432 if (rc
!= KERN_SUCCESS
)
4434 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4442 void set_cpu_affinity (char *cpu_affinity
)
4445 DWORD_PTR aff_mask
= 0;
4453 char *devices
= strdup (cpu_affinity
);
4455 char *next
= strtok (devices
, ",");
4459 uint cpu_id
= atoi (next
);
4474 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4480 aff_mask
|= 1 << (cpu_id
- 1);
4482 CPU_SET ((cpu_id
- 1), &cpuset
);
4485 } while ((next
= strtok (NULL
, ",")) != NULL
);
4491 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4492 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4494 pthread_t thread
= pthread_self ();
4495 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4499 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4501 char *element
, *end
;
4503 end
= (char *) base
+ nmemb
* size
;
4505 for (element
= (char *) base
; element
< end
; element
+= size
)
4506 if (!compar (element
, key
))
4512 int sort_by_u32 (const void *v1
, const void *v2
)
4514 const u32
*s1
= (const u32
*) v1
;
4515 const u32
*s2
= (const u32
*) v2
;
4520 int sort_by_salt (const void *v1
, const void *v2
)
4522 const salt_t
*s1
= (const salt_t
*) v1
;
4523 const salt_t
*s2
= (const salt_t
*) v2
;
4525 const int res1
= s1
->salt_len
- s2
->salt_len
;
4527 if (res1
!= 0) return (res1
);
4529 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4531 if (res2
!= 0) return (res2
);
4539 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4540 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4547 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4548 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4554 int sort_by_salt_buf (const void *v1
, const void *v2
)
4556 const pot_t
*p1
= (const pot_t
*) v1
;
4557 const pot_t
*p2
= (const pot_t
*) v2
;
4559 const hash_t
*h1
= &p1
->hash
;
4560 const hash_t
*h2
= &p2
->hash
;
4562 const salt_t
*s1
= h1
->salt
;
4563 const salt_t
*s2
= h2
->salt
;
4569 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4570 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4576 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4578 const hash_t
*h1
= (const hash_t
*) v1
;
4579 const hash_t
*h2
= (const hash_t
*) v2
;
4581 const salt_t
*s1
= h1
->salt
;
4582 const salt_t
*s2
= h2
->salt
;
4584 // testphase: this should work
4589 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4590 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4593 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4594 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4595 if (s1->salt_len > s2->salt_len) return ( 1);
4596 if (s1->salt_len < s2->salt_len) return (-1);
4598 uint n = s1->salt_len;
4602 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4603 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4610 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4612 const hash_t
*h1
= (const hash_t
*) v1
;
4613 const hash_t
*h2
= (const hash_t
*) v2
;
4615 const salt_t
*s1
= h1
->salt
;
4616 const salt_t
*s2
= h2
->salt
;
4618 // 16 - 2 (since last 2 uints contain the digest)
4623 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4624 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4630 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4632 const hash_t
*h1
= (const hash_t
*) v1
;
4633 const hash_t
*h2
= (const hash_t
*) v2
;
4635 const void *d1
= h1
->digest
;
4636 const void *d2
= h2
->digest
;
4638 return data
.sort_by_digest (d1
, d2
);
4641 int sort_by_hash (const void *v1
, const void *v2
)
4643 const hash_t
*h1
= (const hash_t
*) v1
;
4644 const hash_t
*h2
= (const hash_t
*) v2
;
4648 const salt_t
*s1
= h1
->salt
;
4649 const salt_t
*s2
= h2
->salt
;
4651 int res
= sort_by_salt (s1
, s2
);
4653 if (res
!= 0) return (res
);
4656 const void *d1
= h1
->digest
;
4657 const void *d2
= h2
->digest
;
4659 return data
.sort_by_digest (d1
, d2
);
4662 int sort_by_pot (const void *v1
, const void *v2
)
4664 const pot_t
*p1
= (const pot_t
*) v1
;
4665 const pot_t
*p2
= (const pot_t
*) v2
;
4667 const hash_t
*h1
= &p1
->hash
;
4668 const hash_t
*h2
= &p2
->hash
;
4670 return sort_by_hash (h1
, h2
);
4673 int sort_by_mtime (const void *p1
, const void *p2
)
4675 const char **f1
= (const char **) p1
;
4676 const char **f2
= (const char **) p2
;
4678 struct stat s1
; stat (*f1
, &s1
);
4679 struct stat s2
; stat (*f2
, &s2
);
4681 return s2
.st_mtime
- s1
.st_mtime
;
4684 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4686 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4687 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4689 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4692 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4694 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4695 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4697 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4700 int sort_by_stringptr (const void *p1
, const void *p2
)
4702 const char **s1
= (const char **) p1
;
4703 const char **s2
= (const char **) p2
;
4705 return strcmp (*s1
, *s2
);
4708 int sort_by_dictstat (const void *s1
, const void *s2
)
4710 dictstat_t
*d1
= (dictstat_t
*) s1
;
4711 dictstat_t
*d2
= (dictstat_t
*) s2
;
4714 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4716 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4719 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4722 int sort_by_bitmap (const void *p1
, const void *p2
)
4724 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4725 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4727 return b1
->collisions
- b2
->collisions
;
4730 int sort_by_digest_4_2 (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_4 (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_5 (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_6 (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_8 (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_16 (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_32 (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_4_64 (const void *v1
, const void *v2
)
4844 const u32
*d1
= (const u32
*) v1
;
4845 const u32
*d2
= (const u32
*) v2
;
4851 if (d1
[n
] > d2
[n
]) return ( 1);
4852 if (d1
[n
] < d2
[n
]) return (-1);
4858 int sort_by_digest_8_8 (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_16 (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_8_25 (const void *v1
, const void *v2
)
4892 const u64
*d1
= (const u64
*) v1
;
4893 const u64
*d2
= (const u64
*) v2
;
4899 if (d1
[n
] > d2
[n
]) return ( 1);
4900 if (d1
[n
] < d2
[n
]) return (-1);
4906 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4908 const u32
*d1
= (const u32
*) v1
;
4909 const u32
*d2
= (const u32
*) v2
;
4911 const uint dgst_pos0
= data
.dgst_pos0
;
4912 const uint dgst_pos1
= data
.dgst_pos1
;
4913 const uint dgst_pos2
= data
.dgst_pos2
;
4914 const uint dgst_pos3
= data
.dgst_pos3
;
4916 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4917 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4918 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4919 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4920 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4921 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4922 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4923 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4928 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4930 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4931 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4933 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4935 if (res1
!= 0) return (res1
);
4940 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4942 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4943 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4945 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4947 if (res1
!= 0) return (res1
);
4949 const int res2
= t1
->attack_mode
4952 if (res2
!= 0) return (res2
);
4954 const int res3
= t1
->hash_type
4957 if (res3
!= 0) return (res3
);
4962 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
)
4964 uint outfile_autohex
= data
.outfile_autohex
;
4966 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4968 FILE *debug_fp
= NULL
;
4970 if (debug_file
!= NULL
)
4972 debug_fp
= fopen (debug_file
, "ab");
4974 lock_file (debug_fp
);
4981 if (debug_fp
== NULL
)
4983 log_info ("WARNING: Could not open debug-file for writing");
4987 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4989 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4991 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4994 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4996 if (debug_mode
== 4)
4998 fputc (':', debug_fp
);
5000 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5003 fputc ('\n', debug_fp
);
5005 if (debug_file
!= NULL
) fclose (debug_fp
);
5009 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5011 int needs_hexify
= 0;
5013 if (outfile_autohex
== 1)
5015 for (uint i
= 0; i
< plain_len
; i
++)
5017 if (plain_ptr
[i
] < 0x20)
5024 if (plain_ptr
[i
] > 0x7f)
5033 if (needs_hexify
== 1)
5035 fprintf (fp
, "$HEX[");
5037 for (uint i
= 0; i
< plain_len
; i
++)
5039 fprintf (fp
, "%02x", plain_ptr
[i
]);
5046 fwrite (plain_ptr
, plain_len
, 1, fp
);
5050 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
)
5052 uint outfile_format
= data
.outfile_format
;
5054 char separator
= data
.separator
;
5056 if (outfile_format
& OUTFILE_FMT_HASH
)
5058 fprintf (out_fp
, "%s", out_buf
);
5060 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5062 fputc (separator
, out_fp
);
5065 else if (data
.username
)
5067 if (username
!= NULL
)
5069 for (uint i
= 0; i
< user_len
; i
++)
5071 fprintf (out_fp
, "%c", username
[i
]);
5074 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5076 fputc (separator
, out_fp
);
5081 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5083 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5085 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5087 fputc (separator
, out_fp
);
5091 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5093 for (uint i
= 0; i
< plain_len
; i
++)
5095 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5098 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5100 fputc (separator
, out_fp
);
5104 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5107 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5112 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5114 fprintf (out_fp
, "%llu", crackpos
);
5119 fputc ('\n', out_fp
);
5122 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
)
5126 pot_key
.hash
.salt
= hashes_buf
->salt
;
5127 pot_key
.hash
.digest
= hashes_buf
->digest
;
5129 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5135 input_buf
[input_len
] = 0;
5138 unsigned char *username
= NULL
;
5143 user_t
*user
= hashes_buf
->hash_info
->user
;
5147 username
= (unsigned char *) (user
->user_name
);
5149 user_len
= user
->user_len
;
5153 // do output the line
5154 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5158 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5159 #define LM_MASKED_PLAIN "[notfound]"
5161 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
)
5167 pot_left_key
.hash
.salt
= hash_left
->salt
;
5168 pot_left_key
.hash
.digest
= hash_left
->digest
;
5170 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5174 uint weak_hash_found
= 0;
5176 pot_t pot_right_key
;
5178 pot_right_key
.hash
.salt
= hash_right
->salt
;
5179 pot_right_key
.hash
.digest
= hash_right
->digest
;
5181 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5183 if (pot_right_ptr
== NULL
)
5185 // special case, if "weak hash"
5187 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5189 weak_hash_found
= 1;
5191 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5193 // in theory this is not needed, but we are paranoia:
5195 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5196 pot_right_ptr
->plain_len
= 0;
5200 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5202 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
5207 // at least one half was found:
5211 input_buf
[input_len
] = 0;
5215 unsigned char *username
= NULL
;
5220 user_t
*user
= hash_left
->hash_info
->user
;
5224 username
= (unsigned char *) (user
->user_name
);
5226 user_len
= user
->user_len
;
5230 // mask the part which was not found
5232 uint left_part_masked
= 0;
5233 uint right_part_masked
= 0;
5235 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5237 if (pot_left_ptr
== NULL
)
5239 left_part_masked
= 1;
5241 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5243 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5245 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5246 pot_left_ptr
->plain_len
= mask_plain_len
;
5249 if (pot_right_ptr
== NULL
)
5251 right_part_masked
= 1;
5253 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5255 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5257 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5258 pot_right_ptr
->plain_len
= mask_plain_len
;
5261 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5265 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5267 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5269 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5271 // do output the line
5273 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5275 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5277 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5278 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5281 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
)
5285 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5287 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5289 if (pot_ptr
== NULL
)
5293 input_buf
[input_len
] = 0;
5295 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5299 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
)
5305 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5307 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5311 pot_t pot_right_key
;
5313 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5315 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5317 uint weak_hash_found
= 0;
5319 if (pot_right_ptr
== NULL
)
5321 // special case, if "weak hash"
5323 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5325 weak_hash_found
= 1;
5327 // we just need that pot_right_ptr is not a NULL pointer
5329 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5333 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5335 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5340 // ... at least one part was not cracked
5344 input_buf
[input_len
] = 0;
5346 // only show the hash part which is still not cracked
5348 uint user_len
= input_len
- 32;
5350 char *hash_output
= (char *) mymalloc (33);
5352 memcpy (hash_output
, input_buf
, input_len
);
5354 if (pot_left_ptr
!= NULL
)
5356 // only show right part (because left part was already found)
5358 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5360 hash_output
[user_len
+ 16] = 0;
5363 if (pot_right_ptr
!= NULL
)
5365 // only show left part (because right part was already found)
5367 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5369 hash_output
[user_len
+ 16] = 0;
5372 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5374 myfree (hash_output
);
5376 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5379 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5381 uint opencl_platforms_filter
= 0;
5383 if (opencl_platforms
)
5385 char *platforms
= strdup (opencl_platforms
);
5387 char *next
= strtok (platforms
, ",");
5391 int platform
= atoi (next
);
5393 if (platform
< 1 || platform
> 32)
5395 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5400 opencl_platforms_filter
|= 1 << (platform
- 1);
5402 } while ((next
= strtok (NULL
, ",")) != NULL
);
5408 opencl_platforms_filter
= -1;
5411 return opencl_platforms_filter
;
5414 u32
setup_devices_filter (char *opencl_devices
)
5416 u32 devices_filter
= 0;
5420 char *devices
= strdup (opencl_devices
);
5422 char *next
= strtok (devices
, ",");
5426 int device_id
= atoi (next
);
5428 if (device_id
< 1 || device_id
> 32)
5430 log_error ("ERROR: invalid device_id %u specified", device_id
);
5435 devices_filter
|= 1 << (device_id
- 1);
5437 } while ((next
= strtok (NULL
, ",")) != NULL
);
5443 devices_filter
= -1;
5446 return devices_filter
;
5449 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5451 cl_device_type device_types_filter
= 0;
5453 if (opencl_device_types
)
5455 char *device_types
= strdup (opencl_device_types
);
5457 char *next
= strtok (device_types
, ",");
5461 int device_type
= atoi (next
);
5463 if (device_type
< 1 || device_type
> 3)
5465 log_error ("ERROR: invalid device_type %u specified", device_type
);
5470 device_types_filter
|= 1 << device_type
;
5472 } while ((next
= strtok (NULL
, ",")) != NULL
);
5474 free (device_types
);
5478 // Do not use CPU by default, this often reduces GPU performance because
5479 // the CPU is too busy to handle GPU synchronization
5481 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5484 return device_types_filter
;
5487 u32
get_random_num (const u32 min
, const u32 max
)
5489 if (min
== max
) return (min
);
5491 return ((rand () % (max
- min
)) + min
);
5494 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5496 u32 quotient
= dividend
/ divisor
;
5498 if (dividend
% divisor
) quotient
++;
5503 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5505 u64 quotient
= dividend
/ divisor
;
5507 if (dividend
% divisor
) quotient
++;
5512 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5514 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5515 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5517 if (tm
->tm_year
- 70)
5519 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5520 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5522 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5524 else if (tm
->tm_yday
)
5526 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5527 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5529 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5531 else if (tm
->tm_hour
)
5533 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5534 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5536 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5538 else if (tm
->tm_min
)
5540 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5541 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5543 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5547 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5549 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5553 void format_speed_display (float val
, char *buf
, size_t len
)
5564 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5575 /* generate output */
5579 snprintf (buf
, len
- 1, "%.0f ", val
);
5583 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5587 void lowercase (u8
*buf
, int len
)
5589 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5592 void uppercase (u8
*buf
, int len
)
5594 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5597 int fgetl (FILE *fp
, char *line_buf
)
5603 const int c
= fgetc (fp
);
5605 if (c
== EOF
) break;
5607 line_buf
[line_len
] = (char) c
;
5611 if (line_len
== HCBUFSIZ
) line_len
--;
5613 if (c
== '\n') break;
5616 if (line_len
== 0) return 0;
5618 if (line_buf
[line_len
- 1] == '\n')
5622 line_buf
[line_len
] = 0;
5625 if (line_len
== 0) return 0;
5627 if (line_buf
[line_len
- 1] == '\r')
5631 line_buf
[line_len
] = 0;
5637 int in_superchop (char *buf
)
5639 int len
= strlen (buf
);
5643 if (buf
[len
- 1] == '\n')
5650 if (buf
[len
- 1] == '\r')
5665 char **scan_directory (const char *path
)
5667 char *tmp_path
= mystrdup (path
);
5669 size_t tmp_path_len
= strlen (tmp_path
);
5671 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5673 tmp_path
[tmp_path_len
- 1] = 0;
5675 tmp_path_len
= strlen (tmp_path
);
5678 char **files
= NULL
;
5684 if ((d
= opendir (tmp_path
)) != NULL
)
5690 memset (&e
, 0, sizeof (e
));
5691 struct dirent
*de
= NULL
;
5693 if (readdir_r (d
, &e
, &de
) != 0)
5695 log_error ("ERROR: readdir_r() failed");
5700 if (de
== NULL
) break;
5704 while ((de
= readdir (d
)) != NULL
)
5707 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5709 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5711 char *path_file
= (char *) mymalloc (path_size
+ 1);
5713 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5715 path_file
[path_size
] = 0;
5719 if ((d_test
= opendir (path_file
)) != NULL
)
5727 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5731 files
[num_files
- 1] = path_file
;
5737 else if (errno
== ENOTDIR
)
5739 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5743 files
[num_files
- 1] = mystrdup (path
);
5746 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5750 files
[num_files
- 1] = NULL
;
5757 int count_dictionaries (char **dictionary_files
)
5759 if (dictionary_files
== NULL
) return 0;
5763 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5771 char *stroptitype (const uint opti_type
)
5775 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5776 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5777 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5778 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5779 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5780 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5781 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5782 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5783 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5784 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5785 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5786 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5787 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5788 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5789 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5790 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5791 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5792 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5793 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5799 char *strparser (const uint parser_status
)
5801 switch (parser_status
)
5803 case PARSER_OK
: return ((char *) PA_000
); break;
5804 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5805 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5806 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5807 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5808 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5809 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5810 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5811 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5812 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5813 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5814 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5815 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5816 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5817 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5818 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5819 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5822 return ((char *) PA_255
);
5825 char *strhashtype (const uint hash_mode
)
5829 case 0: return ((char *) HT_00000
); break;
5830 case 10: return ((char *) HT_00010
); break;
5831 case 11: return ((char *) HT_00011
); break;
5832 case 12: return ((char *) HT_00012
); break;
5833 case 20: return ((char *) HT_00020
); break;
5834 case 21: return ((char *) HT_00021
); break;
5835 case 22: return ((char *) HT_00022
); break;
5836 case 23: return ((char *) HT_00023
); break;
5837 case 30: return ((char *) HT_00030
); break;
5838 case 40: return ((char *) HT_00040
); break;
5839 case 50: return ((char *) HT_00050
); break;
5840 case 60: return ((char *) HT_00060
); break;
5841 case 100: return ((char *) HT_00100
); break;
5842 case 101: return ((char *) HT_00101
); break;
5843 case 110: return ((char *) HT_00110
); break;
5844 case 111: return ((char *) HT_00111
); break;
5845 case 112: return ((char *) HT_00112
); break;
5846 case 120: return ((char *) HT_00120
); break;
5847 case 121: return ((char *) HT_00121
); break;
5848 case 122: return ((char *) HT_00122
); break;
5849 case 124: return ((char *) HT_00124
); break;
5850 case 125: return ((char *) HT_00125
); break;
5851 case 130: return ((char *) HT_00130
); break;
5852 case 131: return ((char *) HT_00131
); break;
5853 case 132: return ((char *) HT_00132
); break;
5854 case 133: return ((char *) HT_00133
); break;
5855 case 140: return ((char *) HT_00140
); break;
5856 case 141: return ((char *) HT_00141
); break;
5857 case 150: return ((char *) HT_00150
); break;
5858 case 160: return ((char *) HT_00160
); break;
5859 case 190: return ((char *) HT_00190
); break;
5860 case 200: return ((char *) HT_00200
); break;
5861 case 300: return ((char *) HT_00300
); break;
5862 case 400: return ((char *) HT_00400
); break;
5863 case 500: return ((char *) HT_00500
); break;
5864 case 501: return ((char *) HT_00501
); break;
5865 case 900: return ((char *) HT_00900
); break;
5866 case 910: return ((char *) HT_00910
); break;
5867 case 1000: return ((char *) HT_01000
); break;
5868 case 1100: return ((char *) HT_01100
); break;
5869 case 1400: return ((char *) HT_01400
); break;
5870 case 1410: return ((char *) HT_01410
); break;
5871 case 1420: return ((char *) HT_01420
); break;
5872 case 1421: return ((char *) HT_01421
); break;
5873 case 1430: return ((char *) HT_01430
); break;
5874 case 1440: return ((char *) HT_01440
); break;
5875 case 1441: return ((char *) HT_01441
); break;
5876 case 1450: return ((char *) HT_01450
); break;
5877 case 1460: return ((char *) HT_01460
); break;
5878 case 1500: return ((char *) HT_01500
); break;
5879 case 1600: return ((char *) HT_01600
); break;
5880 case 1700: return ((char *) HT_01700
); break;
5881 case 1710: return ((char *) HT_01710
); break;
5882 case 1711: return ((char *) HT_01711
); break;
5883 case 1720: return ((char *) HT_01720
); break;
5884 case 1722: return ((char *) HT_01722
); break;
5885 case 1730: return ((char *) HT_01730
); break;
5886 case 1731: return ((char *) HT_01731
); break;
5887 case 1740: return ((char *) HT_01740
); break;
5888 case 1750: return ((char *) HT_01750
); break;
5889 case 1760: return ((char *) HT_01760
); break;
5890 case 1800: return ((char *) HT_01800
); break;
5891 case 2100: return ((char *) HT_02100
); break;
5892 case 2400: return ((char *) HT_02400
); break;
5893 case 2410: return ((char *) HT_02410
); break;
5894 case 2500: return ((char *) HT_02500
); break;
5895 case 2600: return ((char *) HT_02600
); break;
5896 case 2611: return ((char *) HT_02611
); break;
5897 case 2612: return ((char *) HT_02612
); break;
5898 case 2711: return ((char *) HT_02711
); break;
5899 case 2811: return ((char *) HT_02811
); break;
5900 case 3000: return ((char *) HT_03000
); break;
5901 case 3100: return ((char *) HT_03100
); break;
5902 case 3200: return ((char *) HT_03200
); break;
5903 case 3710: return ((char *) HT_03710
); break;
5904 case 3711: return ((char *) HT_03711
); break;
5905 case 3800: return ((char *) HT_03800
); break;
5906 case 4300: return ((char *) HT_04300
); break;
5907 case 4400: return ((char *) HT_04400
); break;
5908 case 4500: return ((char *) HT_04500
); break;
5909 case 4700: return ((char *) HT_04700
); break;
5910 case 4800: return ((char *) HT_04800
); break;
5911 case 4900: return ((char *) HT_04900
); break;
5912 case 5000: return ((char *) HT_05000
); break;
5913 case 5100: return ((char *) HT_05100
); break;
5914 case 5200: return ((char *) HT_05200
); break;
5915 case 5300: return ((char *) HT_05300
); break;
5916 case 5400: return ((char *) HT_05400
); break;
5917 case 5500: return ((char *) HT_05500
); break;
5918 case 5600: return ((char *) HT_05600
); break;
5919 case 5700: return ((char *) HT_05700
); break;
5920 case 5800: return ((char *) HT_05800
); break;
5921 case 6000: return ((char *) HT_06000
); break;
5922 case 6100: return ((char *) HT_06100
); break;
5923 case 6211: return ((char *) HT_06211
); break;
5924 case 6212: return ((char *) HT_06212
); break;
5925 case 6213: return ((char *) HT_06213
); break;
5926 case 6221: return ((char *) HT_06221
); break;
5927 case 6222: return ((char *) HT_06222
); break;
5928 case 6223: return ((char *) HT_06223
); break;
5929 case 6231: return ((char *) HT_06231
); break;
5930 case 6232: return ((char *) HT_06232
); break;
5931 case 6233: return ((char *) HT_06233
); break;
5932 case 6241: return ((char *) HT_06241
); break;
5933 case 6242: return ((char *) HT_06242
); break;
5934 case 6243: return ((char *) HT_06243
); break;
5935 case 6300: return ((char *) HT_06300
); break;
5936 case 6400: return ((char *) HT_06400
); break;
5937 case 6500: return ((char *) HT_06500
); break;
5938 case 6600: return ((char *) HT_06600
); break;
5939 case 6700: return ((char *) HT_06700
); break;
5940 case 6800: return ((char *) HT_06800
); break;
5941 case 6900: return ((char *) HT_06900
); break;
5942 case 7100: return ((char *) HT_07100
); break;
5943 case 7200: return ((char *) HT_07200
); break;
5944 case 7300: return ((char *) HT_07300
); break;
5945 case 7400: return ((char *) HT_07400
); break;
5946 case 7500: return ((char *) HT_07500
); break;
5947 case 7600: return ((char *) HT_07600
); break;
5948 case 7700: return ((char *) HT_07700
); break;
5949 case 7800: return ((char *) HT_07800
); break;
5950 case 7900: return ((char *) HT_07900
); break;
5951 case 8000: return ((char *) HT_08000
); break;
5952 case 8100: return ((char *) HT_08100
); break;
5953 case 8200: return ((char *) HT_08200
); break;
5954 case 8300: return ((char *) HT_08300
); break;
5955 case 8400: return ((char *) HT_08400
); break;
5956 case 8500: return ((char *) HT_08500
); break;
5957 case 8600: return ((char *) HT_08600
); break;
5958 case 8700: return ((char *) HT_08700
); break;
5959 case 8800: return ((char *) HT_08800
); break;
5960 case 8900: return ((char *) HT_08900
); break;
5961 case 9000: return ((char *) HT_09000
); break;
5962 case 9100: return ((char *) HT_09100
); break;
5963 case 9200: return ((char *) HT_09200
); break;
5964 case 9300: return ((char *) HT_09300
); break;
5965 case 9400: return ((char *) HT_09400
); break;
5966 case 9500: return ((char *) HT_09500
); break;
5967 case 9600: return ((char *) HT_09600
); break;
5968 case 9700: return ((char *) HT_09700
); break;
5969 case 9710: return ((char *) HT_09710
); break;
5970 case 9720: return ((char *) HT_09720
); break;
5971 case 9800: return ((char *) HT_09800
); break;
5972 case 9810: return ((char *) HT_09810
); break;
5973 case 9820: return ((char *) HT_09820
); break;
5974 case 9900: return ((char *) HT_09900
); break;
5975 case 10000: return ((char *) HT_10000
); break;
5976 case 10100: return ((char *) HT_10100
); break;
5977 case 10200: return ((char *) HT_10200
); break;
5978 case 10300: return ((char *) HT_10300
); break;
5979 case 10400: return ((char *) HT_10400
); break;
5980 case 10410: return ((char *) HT_10410
); break;
5981 case 10420: return ((char *) HT_10420
); break;
5982 case 10500: return ((char *) HT_10500
); break;
5983 case 10600: return ((char *) HT_10600
); break;
5984 case 10700: return ((char *) HT_10700
); break;
5985 case 10800: return ((char *) HT_10800
); break;
5986 case 10900: return ((char *) HT_10900
); break;
5987 case 11000: return ((char *) HT_11000
); break;
5988 case 11100: return ((char *) HT_11100
); break;
5989 case 11200: return ((char *) HT_11200
); break;
5990 case 11300: return ((char *) HT_11300
); break;
5991 case 11400: return ((char *) HT_11400
); break;
5992 case 11500: return ((char *) HT_11500
); break;
5993 case 11600: return ((char *) HT_11600
); break;
5994 case 11700: return ((char *) HT_11700
); break;
5995 case 11800: return ((char *) HT_11800
); break;
5996 case 11900: return ((char *) HT_11900
); break;
5997 case 12000: return ((char *) HT_12000
); break;
5998 case 12100: return ((char *) HT_12100
); break;
5999 case 12200: return ((char *) HT_12200
); break;
6000 case 12300: return ((char *) HT_12300
); break;
6001 case 12400: return ((char *) HT_12400
); break;
6002 case 12500: return ((char *) HT_12500
); break;
6003 case 12600: return ((char *) HT_12600
); break;
6004 case 12700: return ((char *) HT_12700
); break;
6005 case 12800: return ((char *) HT_12800
); break;
6006 case 12900: return ((char *) HT_12900
); break;
6007 case 13000: return ((char *) HT_13000
); break;
6008 case 13100: return ((char *) HT_13100
); break;
6009 case 13200: return ((char *) HT_13200
); break;
6010 case 13300: return ((char *) HT_13300
); break;
6011 case 13400: return ((char *) HT_13400
); break;
6012 case 13500: return ((char *) HT_13500
); break;
6013 case 13600: return ((char *) HT_13600
); break;
6014 case 13711: return ((char *) HT_13711
); break;
6015 case 13712: return ((char *) HT_13712
); break;
6016 case 13713: return ((char *) HT_13713
); break;
6017 case 13721: return ((char *) HT_13721
); break;
6018 case 13722: return ((char *) HT_13722
); break;
6019 case 13723: return ((char *) HT_13723
); break;
6020 case 13731: return ((char *) HT_13731
); break;
6021 case 13732: return ((char *) HT_13732
); break;
6022 case 13733: return ((char *) HT_13733
); break;
6023 case 13741: return ((char *) HT_13741
); break;
6024 case 13742: return ((char *) HT_13742
); break;
6025 case 13743: return ((char *) HT_13743
); break;
6026 case 13751: return ((char *) HT_13751
); break;
6027 case 13752: return ((char *) HT_13752
); break;
6028 case 13753: return ((char *) HT_13753
); break;
6029 case 13761: return ((char *) HT_13761
); break;
6030 case 13762: return ((char *) HT_13762
); break;
6031 case 13763: return ((char *) HT_13763
); break;
6034 return ((char *) "Unknown");
6037 char *strstatus (const uint devices_status
)
6039 switch (devices_status
)
6041 case STATUS_INIT
: return ((char *) ST_0000
); break;
6042 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6043 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6044 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6045 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6046 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6047 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6048 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6049 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6050 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6051 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6054 return ((char *) "Unknown");
6057 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6059 uint hash_type
= data
.hash_type
;
6060 uint hash_mode
= data
.hash_mode
;
6061 uint salt_type
= data
.salt_type
;
6062 uint opts_type
= data
.opts_type
;
6063 uint opti_type
= data
.opti_type
;
6064 uint dgst_size
= data
.dgst_size
;
6066 char *hashfile
= data
.hashfile
;
6070 uint digest_buf
[64] = { 0 };
6072 u64
*digest_buf64
= (u64
*) digest_buf
;
6074 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6076 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6078 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6084 case HASH_TYPE_DESCRYPT
:
6085 FP (digest_buf
[1], digest_buf
[0], tt
);
6088 case HASH_TYPE_DESRACF
:
6089 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6090 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6092 FP (digest_buf
[1], digest_buf
[0], tt
);
6096 FP (digest_buf
[1], digest_buf
[0], tt
);
6099 case HASH_TYPE_NETNTLM
:
6100 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6101 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6102 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6103 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6105 FP (digest_buf
[1], digest_buf
[0], tt
);
6106 FP (digest_buf
[3], digest_buf
[2], tt
);
6109 case HASH_TYPE_BSDICRYPT
:
6110 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6111 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6113 FP (digest_buf
[1], digest_buf
[0], tt
);
6118 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6123 digest_buf
[0] += MD4M_A
;
6124 digest_buf
[1] += MD4M_B
;
6125 digest_buf
[2] += MD4M_C
;
6126 digest_buf
[3] += MD4M_D
;
6130 digest_buf
[0] += MD5M_A
;
6131 digest_buf
[1] += MD5M_B
;
6132 digest_buf
[2] += MD5M_C
;
6133 digest_buf
[3] += MD5M_D
;
6136 case HASH_TYPE_SHA1
:
6137 digest_buf
[0] += SHA1M_A
;
6138 digest_buf
[1] += SHA1M_B
;
6139 digest_buf
[2] += SHA1M_C
;
6140 digest_buf
[3] += SHA1M_D
;
6141 digest_buf
[4] += SHA1M_E
;
6144 case HASH_TYPE_SHA256
:
6145 digest_buf
[0] += SHA256M_A
;
6146 digest_buf
[1] += SHA256M_B
;
6147 digest_buf
[2] += SHA256M_C
;
6148 digest_buf
[3] += SHA256M_D
;
6149 digest_buf
[4] += SHA256M_E
;
6150 digest_buf
[5] += SHA256M_F
;
6151 digest_buf
[6] += SHA256M_G
;
6152 digest_buf
[7] += SHA256M_H
;
6155 case HASH_TYPE_SHA384
:
6156 digest_buf64
[0] += SHA384M_A
;
6157 digest_buf64
[1] += SHA384M_B
;
6158 digest_buf64
[2] += SHA384M_C
;
6159 digest_buf64
[3] += SHA384M_D
;
6160 digest_buf64
[4] += SHA384M_E
;
6161 digest_buf64
[5] += SHA384M_F
;
6162 digest_buf64
[6] += 0;
6163 digest_buf64
[7] += 0;
6166 case HASH_TYPE_SHA512
:
6167 digest_buf64
[0] += SHA512M_A
;
6168 digest_buf64
[1] += SHA512M_B
;
6169 digest_buf64
[2] += SHA512M_C
;
6170 digest_buf64
[3] += SHA512M_D
;
6171 digest_buf64
[4] += SHA512M_E
;
6172 digest_buf64
[5] += SHA512M_F
;
6173 digest_buf64
[6] += SHA512M_G
;
6174 digest_buf64
[7] += SHA512M_H
;
6179 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6181 if (dgst_size
== DGST_SIZE_4_2
)
6183 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6185 else if (dgst_size
== DGST_SIZE_4_4
)
6187 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6189 else if (dgst_size
== DGST_SIZE_4_5
)
6191 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6193 else if (dgst_size
== DGST_SIZE_4_6
)
6195 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6197 else if (dgst_size
== DGST_SIZE_4_8
)
6199 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6201 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6203 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6205 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6207 else if (hash_type
== HASH_TYPE_SHA384
)
6209 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6211 else if (hash_type
== HASH_TYPE_SHA512
)
6213 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6215 else if (hash_type
== HASH_TYPE_GOST
)
6217 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6220 else if (dgst_size
== DGST_SIZE_4_64
)
6222 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6224 else if (dgst_size
== DGST_SIZE_8_25
)
6226 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6230 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6231 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6232 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6238 memset (&salt
, 0, sizeof (salt_t
));
6240 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6242 char *ptr
= (char *) salt
.salt_buf
;
6244 uint len
= salt
.salt_len
;
6246 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6252 case HASH_TYPE_NETNTLM
:
6254 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6255 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6257 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6263 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6265 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6273 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6275 uint max
= salt
.salt_len
/ 4;
6279 for (uint i
= 0; i
< max
; i
++)
6281 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6285 if (opts_type
& OPTS_TYPE_ST_HEX
)
6287 char tmp
[64] = { 0 };
6289 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6291 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6296 memcpy (ptr
, tmp
, len
);
6299 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6301 memset (ptr
+ len
, 0, memset_size
);
6303 salt
.salt_len
= len
;
6307 // some modes require special encoding
6310 uint out_buf_plain
[256] = { 0 };
6311 uint out_buf_salt
[256] = { 0 };
6313 char tmp_buf
[1024] = { 0 };
6315 char *ptr_plain
= (char *) out_buf_plain
;
6316 char *ptr_salt
= (char *) out_buf_salt
;
6318 if (hash_mode
== 22)
6320 char username
[30] = { 0 };
6322 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6324 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6326 u16
*ptr
= (u16
*) digest_buf
;
6328 tmp_buf
[ 0] = sig
[0];
6329 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6330 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6331 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6332 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6333 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6334 tmp_buf
[ 6] = sig
[1];
6335 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6336 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6337 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6338 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6339 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6340 tmp_buf
[12] = sig
[2];
6341 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6342 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6343 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6344 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6345 tmp_buf
[17] = sig
[3];
6346 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6347 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6348 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6349 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6350 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6351 tmp_buf
[23] = sig
[4];
6352 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6353 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6354 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6355 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6356 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6357 tmp_buf
[29] = sig
[5];
6359 snprintf (out_buf
, len
-1, "%s:%s",
6363 else if (hash_mode
== 23)
6365 // do not show the skyper part in output
6367 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6369 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6378 else if (hash_mode
== 101)
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);
6390 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6392 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6394 else if (hash_mode
== 111)
6396 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6398 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6399 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6400 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6401 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6402 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6404 memcpy (tmp_buf
, digest_buf
, 20);
6405 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6407 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6409 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6411 else if ((hash_mode
== 122) || (hash_mode
== 125))
6413 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6414 (char *) salt
.salt_buf
,
6421 else if (hash_mode
== 124)
6423 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6424 (char *) salt
.salt_buf
,
6431 else if (hash_mode
== 131)
6433 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6434 (char *) salt
.salt_buf
,
6442 else if (hash_mode
== 132)
6444 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6445 (char *) salt
.salt_buf
,
6452 else if (hash_mode
== 133)
6454 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6456 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6457 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6458 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6459 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6460 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6462 memcpy (tmp_buf
, digest_buf
, 20);
6464 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6466 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6468 else if (hash_mode
== 141)
6470 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6472 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6474 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6476 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6478 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6479 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6480 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6481 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6482 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6484 memcpy (tmp_buf
, digest_buf
, 20);
6486 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6490 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6492 else if (hash_mode
== 400)
6494 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6496 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6497 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6498 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6499 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6501 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6503 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6505 else if (hash_mode
== 500)
6507 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6509 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6510 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6511 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6512 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6514 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6516 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6518 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6522 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6525 else if (hash_mode
== 501)
6527 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6529 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6530 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6532 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6534 else if (hash_mode
== 1421)
6536 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6538 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6554 else if (hash_mode
== 1441)
6556 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6558 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6560 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6562 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6564 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6565 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6566 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6567 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6568 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6569 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6570 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6571 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6573 memcpy (tmp_buf
, digest_buf
, 32);
6575 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6579 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6581 else if (hash_mode
== 1500)
6583 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6584 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6585 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6586 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6587 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6589 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6591 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6593 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6594 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6596 memcpy (tmp_buf
, digest_buf
, 8);
6598 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6600 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6604 else if (hash_mode
== 1600)
6606 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6608 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6609 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6610 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6611 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6613 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6615 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6617 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6621 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6624 else if (hash_mode
== 1711)
6626 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6628 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6629 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6630 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6631 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6632 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6633 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6634 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6635 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6637 memcpy (tmp_buf
, digest_buf
, 64);
6638 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6640 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6642 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6644 else if (hash_mode
== 1722)
6646 uint
*ptr
= digest_buf
;
6648 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6649 (unsigned char *) salt
.salt_buf
,
6659 else if (hash_mode
== 1731)
6661 uint
*ptr
= digest_buf
;
6663 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6664 (unsigned char *) salt
.salt_buf
,
6674 else if (hash_mode
== 1800)
6678 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6679 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6680 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6681 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6682 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6683 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6684 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6685 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6687 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6689 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6691 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6695 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6698 else if (hash_mode
== 2100)
6702 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6704 salt
.salt_iter
+ 1);
6706 uint signature_len
= strlen (out_buf
);
6708 pos
+= signature_len
;
6709 len
-= signature_len
;
6711 char *salt_ptr
= (char *) salt
.salt_buf
;
6713 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6715 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6716 byte_swap_32 (digest_buf
[0]),
6717 byte_swap_32 (digest_buf
[1]),
6718 byte_swap_32 (digest_buf
[2]),
6719 byte_swap_32 (digest_buf
[3]));
6721 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6723 memcpy (tmp_buf
, digest_buf
, 16);
6725 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6727 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6728 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6729 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6730 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6732 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6733 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6734 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6735 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6737 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6738 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6739 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6740 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6742 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6743 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6744 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6745 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6747 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6748 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6749 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6750 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6754 else if (hash_mode
== 2500)
6756 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6758 wpa_t
*wpa
= &wpas
[salt_pos
];
6760 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6761 (char *) salt
.salt_buf
,
6775 else if (hash_mode
== 4400)
6777 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6778 byte_swap_32 (digest_buf
[0]),
6779 byte_swap_32 (digest_buf
[1]),
6780 byte_swap_32 (digest_buf
[2]),
6781 byte_swap_32 (digest_buf
[3]));
6783 else if (hash_mode
== 4700)
6785 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6786 byte_swap_32 (digest_buf
[0]),
6787 byte_swap_32 (digest_buf
[1]),
6788 byte_swap_32 (digest_buf
[2]),
6789 byte_swap_32 (digest_buf
[3]),
6790 byte_swap_32 (digest_buf
[4]));
6792 else if (hash_mode
== 4800)
6794 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6796 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6801 byte_swap_32 (salt
.salt_buf
[0]),
6802 byte_swap_32 (salt
.salt_buf
[1]),
6803 byte_swap_32 (salt
.salt_buf
[2]),
6804 byte_swap_32 (salt
.salt_buf
[3]),
6807 else if (hash_mode
== 4900)
6809 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6810 byte_swap_32 (digest_buf
[0]),
6811 byte_swap_32 (digest_buf
[1]),
6812 byte_swap_32 (digest_buf
[2]),
6813 byte_swap_32 (digest_buf
[3]),
6814 byte_swap_32 (digest_buf
[4]));
6816 else if (hash_mode
== 5100)
6818 snprintf (out_buf
, len
-1, "%08x%08x",
6822 else if (hash_mode
== 5200)
6824 snprintf (out_buf
, len
-1, "%s", hashfile
);
6826 else if (hash_mode
== 5300)
6828 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6830 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6832 int buf_len
= len
-1;
6836 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6838 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6840 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6842 snprintf (out_buf
, buf_len
, ":");
6848 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6856 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6858 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6860 if ((i
== 0) || (i
== 5))
6862 snprintf (out_buf
, buf_len
, ":");
6868 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6876 for (uint i
= 0; i
< 4; i
++)
6880 snprintf (out_buf
, buf_len
, ":");
6886 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6892 else if (hash_mode
== 5400)
6894 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6896 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6898 int buf_len
= len
-1;
6902 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6904 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6906 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6908 snprintf (out_buf
, buf_len
, ":");
6914 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6922 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6924 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6926 if ((i
== 0) || (i
== 5))
6928 snprintf (out_buf
, buf_len
, ":");
6934 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6942 for (uint i
= 0; i
< 5; i
++)
6946 snprintf (out_buf
, buf_len
, ":");
6952 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6958 else if (hash_mode
== 5500)
6960 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6962 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6964 char user_buf
[64] = { 0 };
6965 char domain_buf
[64] = { 0 };
6966 char srvchall_buf
[1024] = { 0 };
6967 char clichall_buf
[1024] = { 0 };
6969 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6971 char *ptr
= (char *) netntlm
->userdomain_buf
;
6973 user_buf
[i
] = ptr
[j
];
6976 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6978 char *ptr
= (char *) netntlm
->userdomain_buf
;
6980 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6983 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6985 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6987 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6990 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6992 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6994 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6997 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7005 byte_swap_32 (salt
.salt_buf_pc
[0]),
7006 byte_swap_32 (salt
.salt_buf_pc
[1]),
7009 else if (hash_mode
== 5600)
7011 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7013 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7015 char user_buf
[64] = { 0 };
7016 char domain_buf
[64] = { 0 };
7017 char srvchall_buf
[1024] = { 0 };
7018 char clichall_buf
[1024] = { 0 };
7020 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7022 char *ptr
= (char *) netntlm
->userdomain_buf
;
7024 user_buf
[i
] = ptr
[j
];
7027 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7029 char *ptr
= (char *) netntlm
->userdomain_buf
;
7031 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7034 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7036 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7038 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7041 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7043 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7045 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7048 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7058 else if (hash_mode
== 5700)
7060 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7062 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7063 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7064 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7065 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7066 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7067 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7068 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7069 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7071 memcpy (tmp_buf
, digest_buf
, 32);
7073 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7077 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7079 else if (hash_mode
== 5800)
7081 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7082 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7083 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7084 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7085 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7087 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7094 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7096 snprintf (out_buf
, len
-1, "%s", hashfile
);
7098 else if (hash_mode
== 6300)
7100 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7102 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7103 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7104 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7105 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7107 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7109 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7111 else if (hash_mode
== 6400)
7113 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7115 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7117 else if (hash_mode
== 6500)
7119 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7121 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7123 else if (hash_mode
== 6600)
7125 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7127 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7129 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7130 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7132 uint buf_len
= len
- 1;
7134 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7137 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7139 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7144 else if (hash_mode
== 6700)
7146 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7148 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7150 else if (hash_mode
== 6800)
7152 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7154 else if (hash_mode
== 7100)
7156 uint
*ptr
= digest_buf
;
7158 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7160 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7162 uint esalt
[8] = { 0 };
7164 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7165 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7166 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7167 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7168 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7169 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7170 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7171 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7173 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",
7174 SIGNATURE_SHA512OSX
,
7176 esalt
[ 0], esalt
[ 1],
7177 esalt
[ 2], esalt
[ 3],
7178 esalt
[ 4], esalt
[ 5],
7179 esalt
[ 6], esalt
[ 7],
7187 ptr
[15], ptr
[14]);
7189 else if (hash_mode
== 7200)
7191 uint
*ptr
= digest_buf
;
7193 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7195 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7199 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7201 len_used
= strlen (out_buf
);
7203 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7205 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7207 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7210 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",
7218 ptr
[15], ptr
[14]);
7220 else if (hash_mode
== 7300)
7222 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7224 rakp_t
*rakp
= &rakps
[salt_pos
];
7226 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7228 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7231 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7238 else if (hash_mode
== 7400)
7240 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7242 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7243 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7244 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7245 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7246 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7247 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7248 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7249 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7251 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7253 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7255 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7259 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7262 else if (hash_mode
== 7500)
7264 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7266 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7268 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7269 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7271 char data
[128] = { 0 };
7273 char *ptr_data
= data
;
7275 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7277 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7280 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7282 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7287 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7289 (char *) krb5pa
->user
,
7290 (char *) krb5pa
->realm
,
7291 (char *) krb5pa
->salt
,
7294 else if (hash_mode
== 7700)
7296 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7297 (char *) salt
.salt_buf
,
7301 else if (hash_mode
== 7800)
7303 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7304 (char *) salt
.salt_buf
,
7311 else if (hash_mode
== 7900)
7313 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7317 char *tmp
= (char *) salt
.salt_buf_pc
;
7319 ptr_plain
[42] = tmp
[0];
7325 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7327 else if (hash_mode
== 8000)
7329 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7330 (unsigned char *) salt
.salt_buf
,
7340 else if (hash_mode
== 8100)
7342 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7343 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7345 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7346 (unsigned char *) salt
.salt_buf
,
7353 else if (hash_mode
== 8200)
7355 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7357 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7359 char data_buf
[4096] = { 0 };
7361 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7363 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7366 data_buf
[cloudkey
->data_len
* 2] = 0;
7368 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7369 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7370 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7371 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7372 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7373 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7374 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7375 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7377 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7378 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7379 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7380 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7382 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7398 else if (hash_mode
== 8300)
7400 char digest_buf_c
[34] = { 0 };
7402 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7403 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7404 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7405 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7406 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7408 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7410 digest_buf_c
[32] = 0;
7414 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7416 char domain_buf_c
[33] = { 0 };
7418 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7420 for (uint i
= 0; i
< salt_pc_len
; i
++)
7422 const char next
= domain_buf_c
[i
];
7424 domain_buf_c
[i
] = '.';
7429 domain_buf_c
[salt_pc_len
] = 0;
7433 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7435 else if (hash_mode
== 8500)
7437 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7439 else if (hash_mode
== 2612)
7441 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7443 (char *) salt
.salt_buf
,
7449 else if (hash_mode
== 3711)
7451 char *salt_ptr
= (char *) salt
.salt_buf
;
7453 salt_ptr
[salt
.salt_len
- 1] = 0;
7455 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7456 SIGNATURE_MEDIAWIKI_B
,
7463 else if (hash_mode
== 8800)
7465 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7467 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7469 char tmp
[3073] = { 0 };
7471 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7473 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7478 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7479 SIGNATURE_ANDROIDFDE
,
7480 byte_swap_32 (salt
.salt_buf
[0]),
7481 byte_swap_32 (salt
.salt_buf
[1]),
7482 byte_swap_32 (salt
.salt_buf
[2]),
7483 byte_swap_32 (salt
.salt_buf
[3]),
7484 byte_swap_32 (digest_buf
[0]),
7485 byte_swap_32 (digest_buf
[1]),
7486 byte_swap_32 (digest_buf
[2]),
7487 byte_swap_32 (digest_buf
[3]),
7490 else if (hash_mode
== 8900)
7492 uint N
= salt
.scrypt_N
;
7493 uint r
= salt
.scrypt_r
;
7494 uint p
= salt
.scrypt_p
;
7496 char base64_salt
[32] = { 0 };
7498 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7500 memset (tmp_buf
, 0, 46);
7502 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7503 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7504 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7505 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7506 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7507 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7508 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7509 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7510 digest_buf
[8] = 0; // needed for base64_encode ()
7512 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7514 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7522 else if (hash_mode
== 9000)
7524 snprintf (out_buf
, len
-1, "%s", hashfile
);
7526 else if (hash_mode
== 9200)
7530 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7532 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7534 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7538 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7539 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7540 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7541 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7542 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7543 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7544 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7545 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7546 digest_buf
[8] = 0; // needed for base64_encode ()
7548 char tmp_buf
[64] = { 0 };
7550 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7551 tmp_buf
[43] = 0; // cut it here
7555 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7557 else if (hash_mode
== 9300)
7559 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7560 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7561 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7562 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7563 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7564 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7565 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7566 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7567 digest_buf
[8] = 0; // needed for base64_encode ()
7569 char tmp_buf
[64] = { 0 };
7571 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7572 tmp_buf
[43] = 0; // cut it here
7574 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7576 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7578 else if (hash_mode
== 9400)
7580 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7582 office2007_t
*office2007
= &office2007s
[salt_pos
];
7584 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7585 SIGNATURE_OFFICE2007
,
7588 office2007
->keySize
,
7594 office2007
->encryptedVerifier
[0],
7595 office2007
->encryptedVerifier
[1],
7596 office2007
->encryptedVerifier
[2],
7597 office2007
->encryptedVerifier
[3],
7598 office2007
->encryptedVerifierHash
[0],
7599 office2007
->encryptedVerifierHash
[1],
7600 office2007
->encryptedVerifierHash
[2],
7601 office2007
->encryptedVerifierHash
[3],
7602 office2007
->encryptedVerifierHash
[4]);
7604 else if (hash_mode
== 9500)
7606 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7608 office2010_t
*office2010
= &office2010s
[salt_pos
];
7610 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,
7616 office2010
->encryptedVerifier
[0],
7617 office2010
->encryptedVerifier
[1],
7618 office2010
->encryptedVerifier
[2],
7619 office2010
->encryptedVerifier
[3],
7620 office2010
->encryptedVerifierHash
[0],
7621 office2010
->encryptedVerifierHash
[1],
7622 office2010
->encryptedVerifierHash
[2],
7623 office2010
->encryptedVerifierHash
[3],
7624 office2010
->encryptedVerifierHash
[4],
7625 office2010
->encryptedVerifierHash
[5],
7626 office2010
->encryptedVerifierHash
[6],
7627 office2010
->encryptedVerifierHash
[7]);
7629 else if (hash_mode
== 9600)
7631 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7633 office2013_t
*office2013
= &office2013s
[salt_pos
];
7635 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,
7641 office2013
->encryptedVerifier
[0],
7642 office2013
->encryptedVerifier
[1],
7643 office2013
->encryptedVerifier
[2],
7644 office2013
->encryptedVerifier
[3],
7645 office2013
->encryptedVerifierHash
[0],
7646 office2013
->encryptedVerifierHash
[1],
7647 office2013
->encryptedVerifierHash
[2],
7648 office2013
->encryptedVerifierHash
[3],
7649 office2013
->encryptedVerifierHash
[4],
7650 office2013
->encryptedVerifierHash
[5],
7651 office2013
->encryptedVerifierHash
[6],
7652 office2013
->encryptedVerifierHash
[7]);
7654 else if (hash_mode
== 9700)
7656 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7658 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7660 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7661 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7662 byte_swap_32 (salt
.salt_buf
[0]),
7663 byte_swap_32 (salt
.salt_buf
[1]),
7664 byte_swap_32 (salt
.salt_buf
[2]),
7665 byte_swap_32 (salt
.salt_buf
[3]),
7666 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7667 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7668 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7669 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7670 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7671 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7672 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7673 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7675 else if (hash_mode
== 9710)
7677 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7679 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7681 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7682 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7683 byte_swap_32 (salt
.salt_buf
[0]),
7684 byte_swap_32 (salt
.salt_buf
[1]),
7685 byte_swap_32 (salt
.salt_buf
[2]),
7686 byte_swap_32 (salt
.salt_buf
[3]),
7687 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7688 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7689 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7690 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7691 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7692 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7693 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7694 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7696 else if (hash_mode
== 9720)
7698 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7700 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7702 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7704 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7705 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7706 byte_swap_32 (salt
.salt_buf
[0]),
7707 byte_swap_32 (salt
.salt_buf
[1]),
7708 byte_swap_32 (salt
.salt_buf
[2]),
7709 byte_swap_32 (salt
.salt_buf
[3]),
7710 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7711 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7712 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7724 else if (hash_mode
== 9800)
7726 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7728 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7730 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7731 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7736 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7737 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7738 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7739 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7740 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7741 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7742 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7743 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7744 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7746 else if (hash_mode
== 9810)
7748 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7750 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7752 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7753 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7758 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7759 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7760 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7761 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7762 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7763 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7764 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7765 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7766 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7768 else if (hash_mode
== 9820)
7770 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7772 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7774 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7776 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7777 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7782 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7783 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7797 else if (hash_mode
== 10000)
7801 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7803 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7805 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7809 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7810 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7811 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7812 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7813 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7814 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7815 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7816 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7817 digest_buf
[8] = 0; // needed for base64_encode ()
7819 char tmp_buf
[64] = { 0 };
7821 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7825 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7827 else if (hash_mode
== 10100)
7829 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7834 byte_swap_32 (salt
.salt_buf
[0]),
7835 byte_swap_32 (salt
.salt_buf
[1]),
7836 byte_swap_32 (salt
.salt_buf
[2]),
7837 byte_swap_32 (salt
.salt_buf
[3]));
7839 else if (hash_mode
== 10200)
7841 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7843 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7847 char challenge
[100] = { 0 };
7849 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7853 char tmp_buf
[100] = { 0 };
7855 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7856 (char *) cram_md5
->user
,
7862 char response
[100] = { 0 };
7864 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7866 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7868 else if (hash_mode
== 10300)
7870 char tmp_buf
[100] = { 0 };
7872 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7873 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7875 uint tmp_len
= 20 + salt
.salt_len
;
7879 char base64_encoded
[100] = { 0 };
7881 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7883 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7885 else if (hash_mode
== 10400)
7887 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7889 pdf_t
*pdf
= &pdfs
[salt_pos
];
7891 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",
7899 byte_swap_32 (pdf
->id_buf
[0]),
7900 byte_swap_32 (pdf
->id_buf
[1]),
7901 byte_swap_32 (pdf
->id_buf
[2]),
7902 byte_swap_32 (pdf
->id_buf
[3]),
7904 byte_swap_32 (pdf
->u_buf
[0]),
7905 byte_swap_32 (pdf
->u_buf
[1]),
7906 byte_swap_32 (pdf
->u_buf
[2]),
7907 byte_swap_32 (pdf
->u_buf
[3]),
7908 byte_swap_32 (pdf
->u_buf
[4]),
7909 byte_swap_32 (pdf
->u_buf
[5]),
7910 byte_swap_32 (pdf
->u_buf
[6]),
7911 byte_swap_32 (pdf
->u_buf
[7]),
7913 byte_swap_32 (pdf
->o_buf
[0]),
7914 byte_swap_32 (pdf
->o_buf
[1]),
7915 byte_swap_32 (pdf
->o_buf
[2]),
7916 byte_swap_32 (pdf
->o_buf
[3]),
7917 byte_swap_32 (pdf
->o_buf
[4]),
7918 byte_swap_32 (pdf
->o_buf
[5]),
7919 byte_swap_32 (pdf
->o_buf
[6]),
7920 byte_swap_32 (pdf
->o_buf
[7])
7923 else if (hash_mode
== 10410)
7925 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7927 pdf_t
*pdf
= &pdfs
[salt_pos
];
7929 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",
7937 byte_swap_32 (pdf
->id_buf
[0]),
7938 byte_swap_32 (pdf
->id_buf
[1]),
7939 byte_swap_32 (pdf
->id_buf
[2]),
7940 byte_swap_32 (pdf
->id_buf
[3]),
7942 byte_swap_32 (pdf
->u_buf
[0]),
7943 byte_swap_32 (pdf
->u_buf
[1]),
7944 byte_swap_32 (pdf
->u_buf
[2]),
7945 byte_swap_32 (pdf
->u_buf
[3]),
7946 byte_swap_32 (pdf
->u_buf
[4]),
7947 byte_swap_32 (pdf
->u_buf
[5]),
7948 byte_swap_32 (pdf
->u_buf
[6]),
7949 byte_swap_32 (pdf
->u_buf
[7]),
7951 byte_swap_32 (pdf
->o_buf
[0]),
7952 byte_swap_32 (pdf
->o_buf
[1]),
7953 byte_swap_32 (pdf
->o_buf
[2]),
7954 byte_swap_32 (pdf
->o_buf
[3]),
7955 byte_swap_32 (pdf
->o_buf
[4]),
7956 byte_swap_32 (pdf
->o_buf
[5]),
7957 byte_swap_32 (pdf
->o_buf
[6]),
7958 byte_swap_32 (pdf
->o_buf
[7])
7961 else if (hash_mode
== 10420)
7963 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7965 pdf_t
*pdf
= &pdfs
[salt_pos
];
7967 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7969 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",
7977 byte_swap_32 (pdf
->id_buf
[0]),
7978 byte_swap_32 (pdf
->id_buf
[1]),
7979 byte_swap_32 (pdf
->id_buf
[2]),
7980 byte_swap_32 (pdf
->id_buf
[3]),
7982 byte_swap_32 (pdf
->u_buf
[0]),
7983 byte_swap_32 (pdf
->u_buf
[1]),
7984 byte_swap_32 (pdf
->u_buf
[2]),
7985 byte_swap_32 (pdf
->u_buf
[3]),
7986 byte_swap_32 (pdf
->u_buf
[4]),
7987 byte_swap_32 (pdf
->u_buf
[5]),
7988 byte_swap_32 (pdf
->u_buf
[6]),
7989 byte_swap_32 (pdf
->u_buf
[7]),
7991 byte_swap_32 (pdf
->o_buf
[0]),
7992 byte_swap_32 (pdf
->o_buf
[1]),
7993 byte_swap_32 (pdf
->o_buf
[2]),
7994 byte_swap_32 (pdf
->o_buf
[3]),
7995 byte_swap_32 (pdf
->o_buf
[4]),
7996 byte_swap_32 (pdf
->o_buf
[5]),
7997 byte_swap_32 (pdf
->o_buf
[6]),
7998 byte_swap_32 (pdf
->o_buf
[7]),
8006 else if (hash_mode
== 10500)
8008 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8010 pdf_t
*pdf
= &pdfs
[salt_pos
];
8012 if (pdf
->id_len
== 32)
8014 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",
8022 byte_swap_32 (pdf
->id_buf
[0]),
8023 byte_swap_32 (pdf
->id_buf
[1]),
8024 byte_swap_32 (pdf
->id_buf
[2]),
8025 byte_swap_32 (pdf
->id_buf
[3]),
8026 byte_swap_32 (pdf
->id_buf
[4]),
8027 byte_swap_32 (pdf
->id_buf
[5]),
8028 byte_swap_32 (pdf
->id_buf
[6]),
8029 byte_swap_32 (pdf
->id_buf
[7]),
8031 byte_swap_32 (pdf
->u_buf
[0]),
8032 byte_swap_32 (pdf
->u_buf
[1]),
8033 byte_swap_32 (pdf
->u_buf
[2]),
8034 byte_swap_32 (pdf
->u_buf
[3]),
8035 byte_swap_32 (pdf
->u_buf
[4]),
8036 byte_swap_32 (pdf
->u_buf
[5]),
8037 byte_swap_32 (pdf
->u_buf
[6]),
8038 byte_swap_32 (pdf
->u_buf
[7]),
8040 byte_swap_32 (pdf
->o_buf
[0]),
8041 byte_swap_32 (pdf
->o_buf
[1]),
8042 byte_swap_32 (pdf
->o_buf
[2]),
8043 byte_swap_32 (pdf
->o_buf
[3]),
8044 byte_swap_32 (pdf
->o_buf
[4]),
8045 byte_swap_32 (pdf
->o_buf
[5]),
8046 byte_swap_32 (pdf
->o_buf
[6]),
8047 byte_swap_32 (pdf
->o_buf
[7])
8052 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",
8060 byte_swap_32 (pdf
->id_buf
[0]),
8061 byte_swap_32 (pdf
->id_buf
[1]),
8062 byte_swap_32 (pdf
->id_buf
[2]),
8063 byte_swap_32 (pdf
->id_buf
[3]),
8065 byte_swap_32 (pdf
->u_buf
[0]),
8066 byte_swap_32 (pdf
->u_buf
[1]),
8067 byte_swap_32 (pdf
->u_buf
[2]),
8068 byte_swap_32 (pdf
->u_buf
[3]),
8069 byte_swap_32 (pdf
->u_buf
[4]),
8070 byte_swap_32 (pdf
->u_buf
[5]),
8071 byte_swap_32 (pdf
->u_buf
[6]),
8072 byte_swap_32 (pdf
->u_buf
[7]),
8074 byte_swap_32 (pdf
->o_buf
[0]),
8075 byte_swap_32 (pdf
->o_buf
[1]),
8076 byte_swap_32 (pdf
->o_buf
[2]),
8077 byte_swap_32 (pdf
->o_buf
[3]),
8078 byte_swap_32 (pdf
->o_buf
[4]),
8079 byte_swap_32 (pdf
->o_buf
[5]),
8080 byte_swap_32 (pdf
->o_buf
[6]),
8081 byte_swap_32 (pdf
->o_buf
[7])
8085 else if (hash_mode
== 10600)
8087 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8089 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8090 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8092 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8094 else if (hash_mode
== 10700)
8096 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8098 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8099 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8101 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8103 else if (hash_mode
== 10900)
8105 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8107 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8108 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8110 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8112 else if (hash_mode
== 11100)
8114 u32 salt_challenge
= salt
.salt_buf
[0];
8116 salt_challenge
= byte_swap_32 (salt_challenge
);
8118 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8120 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8121 SIGNATURE_POSTGRESQL_AUTH
,
8129 else if (hash_mode
== 11200)
8131 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8132 SIGNATURE_MYSQL_AUTH
,
8133 (unsigned char *) salt
.salt_buf
,
8140 else if (hash_mode
== 11300)
8142 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8144 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8146 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8147 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8148 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8150 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8151 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8152 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8154 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8156 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8158 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8161 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8163 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8165 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8168 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8170 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8172 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8175 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8176 SIGNATURE_BITCOIN_WALLET
,
8180 (unsigned char *) salt
.salt_buf
,
8188 free (cry_master_buf
);
8190 free (public_key_buf
);
8192 else if (hash_mode
== 11400)
8194 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8196 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8197 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8199 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8201 else if (hash_mode
== 11600)
8203 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8205 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8207 const uint data_len
= seven_zip
->data_len
;
8209 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8211 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8213 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8215 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8218 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8219 SIGNATURE_SEVEN_ZIP
,
8223 (char *) seven_zip
->salt_buf
,
8225 seven_zip
->iv_buf
[0],
8226 seven_zip
->iv_buf
[1],
8227 seven_zip
->iv_buf
[2],
8228 seven_zip
->iv_buf
[3],
8230 seven_zip
->data_len
,
8231 seven_zip
->unpack_size
,
8236 else if (hash_mode
== 11700)
8238 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8248 else if (hash_mode
== 11800)
8250 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8268 else if (hash_mode
== 11900)
8270 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8272 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8273 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8275 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8277 else if (hash_mode
== 12000)
8279 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8281 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8282 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8284 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8286 else if (hash_mode
== 12100)
8288 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8290 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8291 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8293 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8295 else if (hash_mode
== 12200)
8297 uint
*ptr_digest
= digest_buf
;
8298 uint
*ptr_salt
= salt
.salt_buf
;
8300 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8307 else if (hash_mode
== 12300)
8309 uint
*ptr_digest
= digest_buf
;
8310 uint
*ptr_salt
= salt
.salt_buf
;
8312 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",
8313 ptr_digest
[ 0], ptr_digest
[ 1],
8314 ptr_digest
[ 2], ptr_digest
[ 3],
8315 ptr_digest
[ 4], ptr_digest
[ 5],
8316 ptr_digest
[ 6], ptr_digest
[ 7],
8317 ptr_digest
[ 8], ptr_digest
[ 9],
8318 ptr_digest
[10], ptr_digest
[11],
8319 ptr_digest
[12], ptr_digest
[13],
8320 ptr_digest
[14], ptr_digest
[15],
8326 else if (hash_mode
== 12400)
8328 // encode iteration count
8330 char salt_iter
[5] = { 0 };
8332 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8333 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8334 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8335 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8340 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8341 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8342 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8343 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8348 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8350 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8351 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8353 memcpy (tmp_buf
, digest_buf
, 8);
8355 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8359 // fill the resulting buffer
8361 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8363 else if (hash_mode
== 12500)
8365 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8367 byte_swap_32 (salt
.salt_buf
[0]),
8368 byte_swap_32 (salt
.salt_buf
[1]),
8374 else if (hash_mode
== 12600)
8376 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8377 digest_buf
[0] + salt
.salt_buf_pc
[0],
8378 digest_buf
[1] + salt
.salt_buf_pc
[1],
8379 digest_buf
[2] + salt
.salt_buf_pc
[2],
8380 digest_buf
[3] + salt
.salt_buf_pc
[3],
8381 digest_buf
[4] + salt
.salt_buf_pc
[4],
8382 digest_buf
[5] + salt
.salt_buf_pc
[5],
8383 digest_buf
[6] + salt
.salt_buf_pc
[6],
8384 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8386 else if (hash_mode
== 12700)
8388 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8390 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8391 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8393 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8395 else if (hash_mode
== 12800)
8397 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8399 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",
8412 byte_swap_32 (digest_buf
[0]),
8413 byte_swap_32 (digest_buf
[1]),
8414 byte_swap_32 (digest_buf
[2]),
8415 byte_swap_32 (digest_buf
[3]),
8416 byte_swap_32 (digest_buf
[4]),
8417 byte_swap_32 (digest_buf
[5]),
8418 byte_swap_32 (digest_buf
[6]),
8419 byte_swap_32 (digest_buf
[7])
8422 else if (hash_mode
== 12900)
8424 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",
8433 byte_swap_32 (digest_buf
[0]),
8434 byte_swap_32 (digest_buf
[1]),
8435 byte_swap_32 (digest_buf
[2]),
8436 byte_swap_32 (digest_buf
[3]),
8437 byte_swap_32 (digest_buf
[4]),
8438 byte_swap_32 (digest_buf
[5]),
8439 byte_swap_32 (digest_buf
[6]),
8440 byte_swap_32 (digest_buf
[7]),
8447 else if (hash_mode
== 13000)
8449 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8451 rar5_t
*rar5
= &rar5s
[salt_pos
];
8453 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8463 byte_swap_32 (digest_buf
[0]),
8464 byte_swap_32 (digest_buf
[1])
8467 else if (hash_mode
== 13100)
8469 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8471 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8473 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8474 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8476 char data
[2560 * 4 * 2] = { 0 };
8478 char *ptr_data
= data
;
8480 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8481 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8486 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8487 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8489 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8491 (char *) krb5tgs
->account_info
,
8495 else if (hash_mode
== 13200)
8497 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8511 else if (hash_mode
== 13300)
8513 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8514 SIGNATURE_AXCRYPT_SHA1
,
8520 else if (hash_mode
== 13400)
8522 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8524 keepass_t
*keepass
= &keepasss
[salt_pos
];
8526 u32 version
= (u32
) keepass
->version
;
8527 u32 rounds
= salt
.salt_iter
;
8528 u32 algorithm
= (u32
) keepass
->algorithm
;
8529 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8531 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8532 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8533 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8534 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8535 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8537 /* specific to version 1 */
8541 /* specific to version 2 */
8542 u32 expected_bytes_len
;
8543 u32
*ptr_expected_bytes
;
8545 u32 final_random_seed_len
;
8546 u32 transf_random_seed_len
;
8548 u32 contents_hash_len
;
8550 transf_random_seed_len
= 8;
8552 contents_hash_len
= 8;
8553 final_random_seed_len
= 8;
8556 final_random_seed_len
= 4;
8558 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8564 char *ptr_data
= out_buf
;
8566 ptr_data
+= strlen(out_buf
);
8571 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8572 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8577 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8578 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8583 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8584 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8591 contents_len
= (u32
) keepass
->contents_len
;
8592 ptr_contents
= (u32
*) keepass
->contents
;
8594 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8595 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8607 char ptr_contents_len
[10] = { 0 };
8609 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8611 sprintf (ptr_data
, "%d", contents_len
);
8613 ptr_data
+= strlen(ptr_contents_len
);
8618 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8619 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8621 else if (version
== 2)
8623 expected_bytes_len
= 8;
8624 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8626 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8627 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8632 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8633 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8647 sprintf (ptr_data
, "%d", keyfile_len
);
8654 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8655 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8658 else if (hash_mode
== 13500)
8660 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8662 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8664 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8666 char pstoken_tmp
[1024 + 1] = { 0 };
8668 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8670 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8672 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8675 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8683 else if (hash_mode
== 13600)
8685 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8687 zip2_t
*zip2
= &zip2s
[salt_pos
];
8689 const u32 salt_len
= zip2
->salt_len
;
8691 char salt_tmp
[32 + 1] = { 0 };
8693 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8695 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8697 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8700 const u32 data_len
= zip2
->data_len
;
8702 char data_tmp
[8192 + 1] = { 0 };
8704 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8706 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8708 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8711 const u32 auth_len
= zip2
->auth_len
;
8713 char auth_tmp
[20 + 1] = { 0 };
8715 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8717 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8719 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8722 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8723 SIGNATURE_ZIP2_START
,
8729 zip2
->compress_length
,
8732 SIGNATURE_ZIP2_STOP
);
8734 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8736 snprintf (out_buf
, len
-1, "%s", hashfile
);
8740 if (hash_type
== HASH_TYPE_MD4
)
8742 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8748 else if (hash_type
== HASH_TYPE_MD5
)
8750 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8756 else if (hash_type
== HASH_TYPE_SHA1
)
8758 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8765 else if (hash_type
== HASH_TYPE_SHA256
)
8767 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8777 else if (hash_type
== HASH_TYPE_SHA384
)
8779 uint
*ptr
= digest_buf
;
8781 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8789 else if (hash_type
== HASH_TYPE_SHA512
)
8791 uint
*ptr
= digest_buf
;
8793 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8803 else if (hash_type
== HASH_TYPE_LM
)
8805 snprintf (out_buf
, len
-1, "%08x%08x",
8809 else if (hash_type
== HASH_TYPE_ORACLEH
)
8811 snprintf (out_buf
, len
-1, "%08X%08X",
8815 else if (hash_type
== HASH_TYPE_BCRYPT
)
8817 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8818 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8820 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8822 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8824 else if (hash_type
== HASH_TYPE_KECCAK
)
8826 uint
*ptr
= digest_buf
;
8828 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",
8856 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8858 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8860 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8867 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8869 digest_buf
[ 0] = digest_buf
[ 0];
8870 digest_buf
[ 1] = digest_buf
[ 1];
8871 digest_buf
[ 2] = digest_buf
[ 2];
8872 digest_buf
[ 3] = digest_buf
[ 3];
8873 digest_buf
[ 4] = digest_buf
[ 4];
8874 digest_buf
[ 5] = digest_buf
[ 5];
8875 digest_buf
[ 6] = digest_buf
[ 6];
8876 digest_buf
[ 7] = digest_buf
[ 7];
8877 digest_buf
[ 8] = digest_buf
[ 8];
8878 digest_buf
[ 9] = digest_buf
[ 9];
8879 digest_buf
[10] = digest_buf
[10];
8880 digest_buf
[11] = digest_buf
[11];
8881 digest_buf
[12] = digest_buf
[12];
8882 digest_buf
[13] = digest_buf
[13];
8883 digest_buf
[14] = digest_buf
[14];
8884 digest_buf
[15] = digest_buf
[15];
8886 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8904 else if (hash_type
== HASH_TYPE_GOST
)
8906 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8916 else if (hash_type
== HASH_TYPE_MYSQL
)
8918 snprintf (out_buf
, len
-1, "%08x%08x",
8922 else if (hash_type
== HASH_TYPE_LOTUS5
)
8924 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8930 else if (hash_type
== HASH_TYPE_LOTUS6
)
8932 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8933 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8934 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8935 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8937 char buf
[16] = { 0 };
8939 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8940 memcpy (buf
+ 5, digest_buf
, 9);
8944 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8946 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8949 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8951 else if (hash_type
== HASH_TYPE_LOTUS8
)
8953 char buf
[52] = { 0 };
8957 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8963 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8967 buf
[26] = salt
.salt_buf_pc
[0];
8968 buf
[27] = salt
.salt_buf_pc
[1];
8972 memcpy (buf
+ 28, digest_buf
, 8);
8974 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8978 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8980 else if (hash_type
== HASH_TYPE_CRC32
)
8982 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8986 if (salt_type
== SALT_TYPE_INTERN
)
8988 size_t pos
= strlen (out_buf
);
8990 out_buf
[pos
] = data
.separator
;
8992 char *ptr
= (char *) salt
.salt_buf
;
8994 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8996 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9000 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9002 memset (hccap
, 0, sizeof (hccap_t
));
9004 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9006 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9008 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9009 wpa_t
*wpa
= &wpas
[salt_pos
];
9011 hccap
->keyver
= wpa
->keyver
;
9013 hccap
->eapol_size
= wpa
->eapol_size
;
9015 if (wpa
->keyver
!= 1)
9017 uint eapol_tmp
[64] = { 0 };
9019 for (uint i
= 0; i
< 64; i
++)
9021 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9024 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9028 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9031 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9032 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9033 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9034 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9036 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9038 uint dgst_size
= data
.dgst_size
;
9040 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9042 if (wpa
->keyver
!= 1)
9044 uint digest_tmp
[4] = { 0 };
9046 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9047 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9048 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9049 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9051 memcpy (hccap
->keymic
, digest_tmp
, 16);
9055 memcpy (hccap
->keymic
, digest_ptr
, 16);
9059 void SuspendThreads ()
9061 if (data
.devices_status
== STATUS_RUNNING
)
9063 hc_timer_set (&data
.timer_paused
);
9065 data
.devices_status
= STATUS_PAUSED
;
9067 log_info ("Paused");
9071 void ResumeThreads ()
9073 if (data
.devices_status
== STATUS_PAUSED
)
9077 hc_timer_get (data
.timer_paused
, ms_paused
);
9079 data
.ms_paused
+= ms_paused
;
9081 data
.devices_status
= STATUS_RUNNING
;
9083 log_info ("Resumed");
9089 if (data
.devices_status
!= STATUS_RUNNING
) return;
9091 data
.devices_status
= STATUS_BYPASS
;
9093 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9096 void stop_at_checkpoint ()
9098 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9100 if (data
.devices_status
!= STATUS_RUNNING
) return;
9103 // this feature only makes sense if --restore-disable was not specified
9105 if (data
.restore_disable
== 1)
9107 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9112 // check if monitoring of Restore Point updates should be enabled or disabled
9114 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9116 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9118 // save the current restore point value
9120 data
.checkpoint_cur_words
= get_lowest_words_done ();
9122 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9126 data
.devices_status
= STATUS_RUNNING
;
9128 // reset the global value for checkpoint checks
9130 data
.checkpoint_cur_words
= 0;
9132 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9138 if (data
.devices_status
== STATUS_INIT
) return;
9139 if (data
.devices_status
== STATUS_STARTING
) return;
9141 data
.devices_status
= STATUS_ABORTED
;
9146 if (data
.devices_status
== STATUS_INIT
) return;
9147 if (data
.devices_status
== STATUS_STARTING
) return;
9149 data
.devices_status
= STATUS_QUIT
;
9152 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9154 FILE *fp
= fopen (kernel_file
, "rb");
9160 memset (&st
, 0, sizeof (st
));
9162 stat (kernel_file
, &st
);
9164 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9166 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9168 if (num_read
!= (size_t) st
.st_size
)
9170 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9177 buf
[st
.st_size
] = 0;
9179 for (int i
= 0; i
< num_devices
; i
++)
9181 kernel_lengths
[i
] = (size_t) st
.st_size
;
9183 kernel_sources
[i
] = buf
;
9188 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9196 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9198 if (binary_size
> 0)
9200 FILE *fp
= fopen (dst
, "wb");
9203 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9214 restore_data_t
*init_restore (int argc
, char **argv
)
9216 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9218 if (data
.restore_disable
== 0)
9220 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9224 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9228 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9237 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9239 int pidbin_len
= -1;
9242 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9244 FILE *fd
= fopen (pidbin
, "rb");
9248 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9250 pidbin
[pidbin_len
] = 0;
9254 char *argv0_r
= strrchr (argv
[0], '/');
9256 char *pidbin_r
= strrchr (pidbin
, '/');
9258 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9260 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9262 if (strcmp (argv0_r
, pidbin_r
) == 0)
9264 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9271 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9273 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9275 int pidbin2_len
= -1;
9277 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9278 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9280 pidbin
[pidbin_len
] = 0;
9281 pidbin2
[pidbin2_len
] = 0;
9285 if (strcmp (pidbin
, pidbin2
) == 0)
9287 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9300 if (rd
->version_bin
< RESTORE_MIN
)
9302 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9309 memset (rd
, 0, sizeof (restore_data_t
));
9311 rd
->version_bin
= VERSION_BIN
;
9314 rd
->pid
= getpid ();
9316 rd
->pid
= GetCurrentProcessId ();
9319 if (getcwd (rd
->cwd
, 255) == NULL
)
9332 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9334 FILE *fp
= fopen (eff_restore_file
, "rb");
9338 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9343 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9345 log_error ("ERROR: cannot read %s", eff_restore_file
);
9350 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9352 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9354 for (uint i
= 0; i
< rd
->argc
; i
++)
9356 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9358 log_error ("ERROR: cannot read %s", eff_restore_file
);
9363 size_t len
= strlen (buf
);
9365 if (len
) buf
[len
- 1] = 0;
9367 rd
->argv
[i
] = mystrdup (buf
);
9374 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9376 if (chdir (rd
->cwd
))
9378 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9379 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9380 " https://github.com/philsmd/analyze_hc_restore\n"
9381 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9387 u64
get_lowest_words_done ()
9391 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9393 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9395 if (device_param
->skipped
) continue;
9397 const u64 words_done
= device_param
->words_done
;
9399 if (words_done
< words_cur
) words_cur
= words_done
;
9402 // It's possible that a device's workload isn't finished right after a restore-case.
9403 // In that case, this function would return 0 and overwrite the real restore point
9404 // There's also data.words_cur which is set to rd->words_cur but it changes while
9405 // the attack is running therefore we should stick to rd->words_cur.
9406 // Note that -s influences rd->words_cur we should keep a close look on that.
9408 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9413 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9415 u64 words_cur
= get_lowest_words_done ();
9417 rd
->words_cur
= words_cur
;
9419 FILE *fp
= fopen (new_restore_file
, "wb");
9423 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9428 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9430 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9435 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9437 for (uint i
= 0; i
< rd
->argc
; i
++)
9439 fprintf (fp
, "%s", rd
->argv
[i
]);
9445 fsync (fileno (fp
));
9450 void cycle_restore ()
9452 const char *eff_restore_file
= data
.eff_restore_file
;
9453 const char *new_restore_file
= data
.new_restore_file
;
9455 restore_data_t
*rd
= data
.rd
;
9457 write_restore (new_restore_file
, rd
);
9461 memset (&st
, 0, sizeof(st
));
9463 if (stat (eff_restore_file
, &st
) == 0)
9465 if (unlink (eff_restore_file
))
9467 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9471 if (rename (new_restore_file
, eff_restore_file
))
9473 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9477 void check_checkpoint ()
9479 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9481 u64 words_cur
= get_lowest_words_done ();
9483 if (words_cur
!= data
.checkpoint_cur_words
)
9493 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9497 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9499 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9501 myfree (alias
->device_name
);
9502 myfree (alias
->alias_name
);
9505 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9507 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9509 myfree (entry
->device_name
);
9512 myfree (tuning_db
->alias_buf
);
9513 myfree (tuning_db
->entry_buf
);
9518 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9520 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9522 int num_lines
= count_lines (fp
);
9524 // a bit over-allocated
9526 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9527 tuning_db
->alias_cnt
= 0;
9529 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9530 tuning_db
->entry_cnt
= 0;
9535 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9537 FILE *fp
= fopen (tuning_db_file
, "rb");
9541 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9546 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9552 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9556 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9558 if (line_buf
== NULL
) break;
9562 const int line_len
= in_superchop (line_buf
);
9564 if (line_len
== 0) continue;
9566 if (line_buf
[0] == '#') continue;
9570 char *token_ptr
[7] = { NULL
};
9574 char *next
= strtok (line_buf
, "\t ");
9576 token_ptr
[token_cnt
] = next
;
9580 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9582 token_ptr
[token_cnt
] = next
;
9589 char *device_name
= token_ptr
[0];
9590 char *alias_name
= token_ptr
[1];
9592 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9594 alias
->device_name
= mystrdup (device_name
);
9595 alias
->alias_name
= mystrdup (alias_name
);
9597 tuning_db
->alias_cnt
++;
9599 else if (token_cnt
== 6)
9601 if ((token_ptr
[1][0] != '0') &&
9602 (token_ptr
[1][0] != '1') &&
9603 (token_ptr
[1][0] != '3') &&
9604 (token_ptr
[1][0] != '*'))
9606 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9611 if ((token_ptr
[3][0] != '1') &&
9612 (token_ptr
[3][0] != '2') &&
9613 (token_ptr
[3][0] != '4') &&
9614 (token_ptr
[3][0] != '8') &&
9615 (token_ptr
[3][0] != 'N'))
9617 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9622 char *device_name
= token_ptr
[0];
9624 int attack_mode
= -1;
9626 int vector_width
= -1;
9627 int kernel_accel
= -1;
9628 int kernel_loops
= -1;
9630 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9631 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9632 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9634 if (token_ptr
[4][0] != 'A')
9636 kernel_accel
= atoi (token_ptr
[4]);
9638 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9640 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9650 if (token_ptr
[5][0] != 'A')
9652 kernel_loops
= atoi (token_ptr
[5]);
9654 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9656 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9666 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9668 entry
->device_name
= mystrdup (device_name
);
9669 entry
->attack_mode
= attack_mode
;
9670 entry
->hash_type
= hash_type
;
9671 entry
->vector_width
= vector_width
;
9672 entry
->kernel_accel
= kernel_accel
;
9673 entry
->kernel_loops
= kernel_loops
;
9675 tuning_db
->entry_cnt
++;
9679 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9689 // todo: print loaded 'cnt' message
9691 // sort the database
9693 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9694 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9699 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9701 static tuning_db_entry_t s
;
9703 // first we need to convert all spaces in the device_name to underscore
9705 char *device_name_nospace
= strdup (device_param
->device_name
);
9707 int device_name_length
= strlen (device_name_nospace
);
9711 for (i
= 0; i
< device_name_length
; i
++)
9713 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9716 // find out if there's an alias configured
9718 tuning_db_alias_t a
;
9720 a
.device_name
= device_name_nospace
;
9722 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
);
9724 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9726 // attack-mode 6 and 7 are attack-mode 1 basically
9728 if (attack_mode
== 6) attack_mode
= 1;
9729 if (attack_mode
== 7) attack_mode
= 1;
9731 // bsearch is not ideal but fast enough
9733 s
.device_name
= device_name_nospace
;
9734 s
.attack_mode
= attack_mode
;
9735 s
.hash_type
= hash_type
;
9737 tuning_db_entry_t
*entry
= NULL
;
9739 // this will produce all 2^3 combinations required
9741 for (i
= 0; i
< 8; i
++)
9743 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9744 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9745 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9747 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9749 if (entry
!= NULL
) break;
9751 // in non-wildcard mode do some additional checks:
9755 // in case we have an alias-name
9757 if (alias_name
!= NULL
)
9759 s
.device_name
= alias_name
;
9761 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9763 if (entry
!= NULL
) break;
9766 // or by device type
9768 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9770 s
.device_name
= "DEVICE_TYPE_CPU";
9772 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9774 s
.device_name
= "DEVICE_TYPE_GPU";
9776 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9778 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9781 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9783 if (entry
!= NULL
) break;
9787 // free converted device_name
9789 myfree (device_name_nospace
);
9798 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9800 u8 tmp
[256] = { 0 };
9802 if (salt_len
> sizeof (tmp
))
9807 memcpy (tmp
, in
, salt_len
);
9809 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9811 if ((salt_len
% 2) == 0)
9813 u32 new_salt_len
= salt_len
/ 2;
9815 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9820 tmp
[i
] = hex_convert (p1
) << 0;
9821 tmp
[i
] |= hex_convert (p0
) << 4;
9824 salt_len
= new_salt_len
;
9831 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9833 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9836 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9838 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9842 u32
*tmp_uint
= (u32
*) tmp
;
9844 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9845 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9846 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9847 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9848 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9849 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9850 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9851 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9852 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9853 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9855 salt_len
= salt_len
* 2;
9863 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9865 lowercase (tmp
, salt_len
);
9868 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9870 uppercase (tmp
, salt_len
);
9875 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9880 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9885 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9887 u32
*tmp_uint
= (uint
*) tmp
;
9893 for (u32 i
= 0; i
< max
; i
++)
9895 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9898 // Important: we may need to increase the length of memcpy since
9899 // we don't want to "loose" some swapped bytes (could happen if
9900 // they do not perfectly fit in the 4-byte blocks)
9901 // Memcpy does always copy the bytes in the BE order, but since
9902 // we swapped them, some important bytes could be in positions
9903 // we normally skip with the original len
9905 if (len
% 4) len
+= 4 - (len
% 4);
9908 memcpy (out
, tmp
, len
);
9913 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9915 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9917 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9919 u32
*digest
= (u32
*) hash_buf
->digest
;
9921 salt_t
*salt
= hash_buf
->salt
;
9923 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9925 char *iter_pos
= input_buf
+ 4;
9927 salt
->salt_iter
= 1 << atoi (iter_pos
);
9929 char *salt_pos
= strchr (iter_pos
, '$');
9931 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9937 salt
->salt_len
= salt_len
;
9939 u8 tmp_buf
[100] = { 0 };
9941 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9945 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9947 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9948 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9949 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9950 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9952 char *hash_pos
= salt_pos
+ 22;
9954 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9956 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9958 memcpy (digest
, tmp_buf
, 24);
9960 digest
[0] = byte_swap_32 (digest
[0]);
9961 digest
[1] = byte_swap_32 (digest
[1]);
9962 digest
[2] = byte_swap_32 (digest
[2]);
9963 digest
[3] = byte_swap_32 (digest
[3]);
9964 digest
[4] = byte_swap_32 (digest
[4]);
9965 digest
[5] = byte_swap_32 (digest
[5]);
9967 digest
[5] &= ~0xff; // its just 23 not 24 !
9972 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9974 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9976 u32
*digest
= (u32
*) hash_buf
->digest
;
9978 u8 tmp_buf
[100] = { 0 };
9980 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9982 memcpy (digest
, tmp_buf
, 32);
9984 digest
[0] = byte_swap_32 (digest
[0]);
9985 digest
[1] = byte_swap_32 (digest
[1]);
9986 digest
[2] = byte_swap_32 (digest
[2]);
9987 digest
[3] = byte_swap_32 (digest
[3]);
9988 digest
[4] = byte_swap_32 (digest
[4]);
9989 digest
[5] = byte_swap_32 (digest
[5]);
9990 digest
[6] = byte_swap_32 (digest
[6]);
9991 digest
[7] = byte_swap_32 (digest
[7]);
9993 digest
[0] -= SHA256M_A
;
9994 digest
[1] -= SHA256M_B
;
9995 digest
[2] -= SHA256M_C
;
9996 digest
[3] -= SHA256M_D
;
9997 digest
[4] -= SHA256M_E
;
9998 digest
[5] -= SHA256M_F
;
9999 digest
[6] -= SHA256M_G
;
10000 digest
[7] -= SHA256M_H
;
10002 return (PARSER_OK
);
10005 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10007 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10009 u32
*digest
= (u32
*) hash_buf
->digest
;
10011 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10012 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10014 digest
[0] = byte_swap_32 (digest
[0]);
10015 digest
[1] = byte_swap_32 (digest
[1]);
10019 IP (digest
[0], digest
[1], tt
);
10021 digest
[0] = digest
[0];
10022 digest
[1] = digest
[1];
10026 return (PARSER_OK
);
10029 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10031 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10033 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10035 u32
*digest
= (u32
*) hash_buf
->digest
;
10037 salt_t
*salt
= hash_buf
->salt
;
10039 char *hash_pos
= input_buf
+ 10;
10041 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10042 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10043 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10044 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10045 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10047 digest
[0] -= SHA1M_A
;
10048 digest
[1] -= SHA1M_B
;
10049 digest
[2] -= SHA1M_C
;
10050 digest
[3] -= SHA1M_D
;
10051 digest
[4] -= SHA1M_E
;
10053 uint salt_len
= 10;
10055 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10057 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10059 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10061 salt
->salt_len
= salt_len
;
10063 return (PARSER_OK
);
10066 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10068 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10070 u32
*digest
= (u32
*) hash_buf
->digest
;
10072 salt_t
*salt
= hash_buf
->salt
;
10074 char *hash_pos
= input_buf
+ 8;
10076 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10077 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10078 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10079 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10080 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10082 digest
[0] -= SHA1M_A
;
10083 digest
[1] -= SHA1M_B
;
10084 digest
[2] -= SHA1M_C
;
10085 digest
[3] -= SHA1M_D
;
10086 digest
[4] -= SHA1M_E
;
10090 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10092 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10094 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10096 salt
->salt_len
= salt_len
;
10098 return (PARSER_OK
);
10101 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10103 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10105 u64
*digest
= (u64
*) hash_buf
->digest
;
10107 salt_t
*salt
= hash_buf
->salt
;
10109 char *hash_pos
= input_buf
+ 8;
10111 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10112 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10113 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10114 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10115 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10116 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10117 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10118 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10120 digest
[0] -= SHA512M_A
;
10121 digest
[1] -= SHA512M_B
;
10122 digest
[2] -= SHA512M_C
;
10123 digest
[3] -= SHA512M_D
;
10124 digest
[4] -= SHA512M_E
;
10125 digest
[5] -= SHA512M_F
;
10126 digest
[6] -= SHA512M_G
;
10127 digest
[7] -= SHA512M_H
;
10131 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10133 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10137 salt
->salt_len
= salt_len
;
10139 return (PARSER_OK
);
10142 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10144 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10146 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10150 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10153 u32
*digest
= (u32
*) hash_buf
->digest
;
10155 salt_t
*salt
= hash_buf
->salt
;
10157 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10158 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10159 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10160 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10162 digest
[0] = byte_swap_32 (digest
[0]);
10163 digest
[1] = byte_swap_32 (digest
[1]);
10164 digest
[2] = byte_swap_32 (digest
[2]);
10165 digest
[3] = byte_swap_32 (digest
[3]);
10167 digest
[0] -= MD5M_A
;
10168 digest
[1] -= MD5M_B
;
10169 digest
[2] -= MD5M_C
;
10170 digest
[3] -= MD5M_D
;
10172 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10174 uint salt_len
= input_len
- 32 - 1;
10176 char *salt_buf
= input_buf
+ 32 + 1;
10178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10184 salt
->salt_len
= salt_len
;
10186 return (PARSER_OK
);
10189 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10191 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10193 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10197 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10202 char clean_input_buf
[32] = { 0 };
10204 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10205 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10207 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10211 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10217 clean_input_buf
[k
] = input_buf
[i
];
10225 u32
*digest
= (u32
*) hash_buf
->digest
;
10227 salt_t
*salt
= hash_buf
->salt
;
10229 u32 a
, b
, c
, d
, e
, f
;
10231 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10232 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10233 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10234 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10235 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10236 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10238 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10239 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10241 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10242 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10243 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10244 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10245 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10246 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10248 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10249 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10251 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10252 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10253 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10254 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10255 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10256 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10258 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10259 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10261 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10262 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10263 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10264 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10265 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10266 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10268 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10269 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10271 digest
[0] = byte_swap_32 (digest
[0]);
10272 digest
[1] = byte_swap_32 (digest
[1]);
10273 digest
[2] = byte_swap_32 (digest
[2]);
10274 digest
[3] = byte_swap_32 (digest
[3]);
10276 digest
[0] -= MD5M_A
;
10277 digest
[1] -= MD5M_B
;
10278 digest
[2] -= MD5M_C
;
10279 digest
[3] -= MD5M_D
;
10281 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10283 uint salt_len
= input_len
- 30 - 1;
10285 char *salt_buf
= input_buf
+ 30 + 1;
10287 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10289 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10291 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10292 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10294 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10296 salt
->salt_len
= salt_len
;
10298 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10300 salt
->salt_len
+= 22;
10302 return (PARSER_OK
);
10305 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10307 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10309 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10313 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10316 u32
*digest
= (u32
*) hash_buf
->digest
;
10318 salt_t
*salt
= hash_buf
->salt
;
10320 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10321 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10322 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10323 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10324 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10326 digest
[0] -= SHA1M_A
;
10327 digest
[1] -= SHA1M_B
;
10328 digest
[2] -= SHA1M_C
;
10329 digest
[3] -= SHA1M_D
;
10330 digest
[4] -= SHA1M_E
;
10332 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10334 uint salt_len
= input_len
- 40 - 1;
10336 char *salt_buf
= input_buf
+ 40 + 1;
10338 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10340 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10342 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10344 salt
->salt_len
= salt_len
;
10346 return (PARSER_OK
);
10349 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10351 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10353 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10357 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10360 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10362 char *iter_pos
= input_buf
+ 6;
10364 salt_t
*salt
= hash_buf
->salt
;
10366 uint iter
= atoi (iter_pos
);
10370 iter
= ROUNDS_DCC2
;
10373 salt
->salt_iter
= iter
- 1;
10375 char *salt_pos
= strchr (iter_pos
, '#');
10377 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10381 char *digest_pos
= strchr (salt_pos
, '#');
10383 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10387 uint salt_len
= digest_pos
- salt_pos
- 1;
10389 u32
*digest
= (u32
*) hash_buf
->digest
;
10391 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10392 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10393 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10394 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10396 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10398 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10400 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10402 salt
->salt_len
= salt_len
;
10404 return (PARSER_OK
);
10407 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10409 u32
*digest
= (u32
*) hash_buf
->digest
;
10411 salt_t
*salt
= hash_buf
->salt
;
10413 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10417 memcpy (&in
, input_buf
, input_len
);
10419 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10421 memcpy (digest
, in
.keymic
, 16);
10424 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10425 The phrase "Pairwise key expansion"
10426 Access Point Address (referred to as Authenticator Address AA)
10427 Supplicant Address (referred to as Supplicant Address SA)
10428 Access Point Nonce (referred to as Authenticator Anonce)
10429 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10432 uint salt_len
= strlen (in
.essid
);
10436 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10438 return (PARSER_SALT_LENGTH
);
10441 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10443 salt
->salt_len
= salt_len
;
10445 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10447 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10449 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10451 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10453 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10454 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10458 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10459 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10462 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10464 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10465 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10469 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10470 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10473 for (int i
= 0; i
< 25; i
++)
10475 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10478 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10479 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10480 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10481 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10483 wpa
->keyver
= in
.keyver
;
10485 if (wpa
->keyver
> 255)
10487 log_info ("ATTENTION!");
10488 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10489 log_info (" This could be due to a recent aircrack-ng bug.");
10490 log_info (" The key version was automatically reset to a reasonable value.");
10493 wpa
->keyver
&= 0xff;
10496 wpa
->eapol_size
= in
.eapol_size
;
10498 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10500 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10502 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10504 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10506 if (wpa
->keyver
== 1)
10512 digest
[0] = byte_swap_32 (digest
[0]);
10513 digest
[1] = byte_swap_32 (digest
[1]);
10514 digest
[2] = byte_swap_32 (digest
[2]);
10515 digest
[3] = byte_swap_32 (digest
[3]);
10517 for (int i
= 0; i
< 64; i
++)
10519 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10523 uint32_t *p0
= (uint32_t *) in
.essid
;
10527 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10528 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10530 salt
->salt_buf
[10] = c0
;
10531 salt
->salt_buf
[11] = c1
;
10533 return (PARSER_OK
);
10536 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10538 u32
*digest
= (u32
*) hash_buf
->digest
;
10540 salt_t
*salt
= hash_buf
->salt
;
10542 if (input_len
== 0)
10544 log_error ("Password Safe v2 container not specified");
10549 FILE *fp
= fopen (input_buf
, "rb");
10553 log_error ("%s: %s", input_buf
, strerror (errno
));
10560 memset (&buf
, 0, sizeof (psafe2_hdr
));
10562 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10566 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10568 salt
->salt_buf
[0] = buf
.random
[0];
10569 salt
->salt_buf
[1] = buf
.random
[1];
10571 salt
->salt_len
= 8;
10572 salt
->salt_iter
= 1000;
10574 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10575 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10576 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10577 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10578 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10580 return (PARSER_OK
);
10583 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10585 u32
*digest
= (u32
*) hash_buf
->digest
;
10587 salt_t
*salt
= hash_buf
->salt
;
10589 if (input_len
== 0)
10591 log_error (".psafe3 not specified");
10596 FILE *fp
= fopen (input_buf
, "rb");
10600 log_error ("%s: %s", input_buf
, strerror (errno
));
10607 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10611 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10613 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10615 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10617 salt
->salt_iter
= in
.iterations
+ 1;
10619 salt
->salt_buf
[0] = in
.salt_buf
[0];
10620 salt
->salt_buf
[1] = in
.salt_buf
[1];
10621 salt
->salt_buf
[2] = in
.salt_buf
[2];
10622 salt
->salt_buf
[3] = in
.salt_buf
[3];
10623 salt
->salt_buf
[4] = in
.salt_buf
[4];
10624 salt
->salt_buf
[5] = in
.salt_buf
[5];
10625 salt
->salt_buf
[6] = in
.salt_buf
[6];
10626 salt
->salt_buf
[7] = in
.salt_buf
[7];
10628 salt
->salt_len
= 32;
10630 digest
[0] = in
.hash_buf
[0];
10631 digest
[1] = in
.hash_buf
[1];
10632 digest
[2] = in
.hash_buf
[2];
10633 digest
[3] = in
.hash_buf
[3];
10634 digest
[4] = in
.hash_buf
[4];
10635 digest
[5] = in
.hash_buf
[5];
10636 digest
[6] = in
.hash_buf
[6];
10637 digest
[7] = in
.hash_buf
[7];
10639 digest
[0] = byte_swap_32 (digest
[0]);
10640 digest
[1] = byte_swap_32 (digest
[1]);
10641 digest
[2] = byte_swap_32 (digest
[2]);
10642 digest
[3] = byte_swap_32 (digest
[3]);
10643 digest
[4] = byte_swap_32 (digest
[4]);
10644 digest
[5] = byte_swap_32 (digest
[5]);
10645 digest
[6] = byte_swap_32 (digest
[6]);
10646 digest
[7] = byte_swap_32 (digest
[7]);
10648 return (PARSER_OK
);
10651 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10653 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10655 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10657 u32
*digest
= (u32
*) hash_buf
->digest
;
10659 salt_t
*salt
= hash_buf
->salt
;
10661 char *iter_pos
= input_buf
+ 3;
10663 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10665 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10667 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10669 salt
->salt_iter
= salt_iter
;
10671 char *salt_pos
= iter_pos
+ 1;
10675 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10677 salt
->salt_len
= salt_len
;
10679 char *hash_pos
= salt_pos
+ salt_len
;
10681 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10683 return (PARSER_OK
);
10686 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10688 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10690 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10692 u32
*digest
= (u32
*) hash_buf
->digest
;
10694 salt_t
*salt
= hash_buf
->salt
;
10696 char *salt_pos
= input_buf
+ 3;
10698 uint iterations_len
= 0;
10700 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10704 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10706 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10707 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10711 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10715 iterations_len
+= 8;
10719 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10722 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10724 char *hash_pos
= strchr (salt_pos
, '$');
10726 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10728 uint salt_len
= hash_pos
- salt_pos
;
10730 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10732 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10734 salt
->salt_len
= salt_len
;
10738 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10740 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10742 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10744 return (PARSER_OK
);
10747 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10749 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10751 u32
*digest
= (u32
*) hash_buf
->digest
;
10753 salt_t
*salt
= hash_buf
->salt
;
10755 char *salt_pos
= input_buf
+ 6;
10757 uint iterations_len
= 0;
10759 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10763 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10765 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10766 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10770 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10774 iterations_len
+= 8;
10778 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10781 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10783 char *hash_pos
= strchr (salt_pos
, '$');
10785 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10787 uint salt_len
= hash_pos
- salt_pos
;
10789 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10791 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10793 salt
->salt_len
= salt_len
;
10797 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10799 return (PARSER_OK
);
10802 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10804 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10806 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10808 u32
*digest
= (u32
*) hash_buf
->digest
;
10810 salt_t
*salt
= hash_buf
->salt
;
10812 char *salt_pos
= input_buf
+ 14;
10814 char *hash_pos
= strchr (salt_pos
, '*');
10816 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10820 uint salt_len
= hash_pos
- salt_pos
- 1;
10822 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10824 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10826 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10828 salt
->salt_len
= salt_len
;
10830 u8 tmp_buf
[100] = { 0 };
10832 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10834 memcpy (digest
, tmp_buf
, 20);
10836 digest
[0] = byte_swap_32 (digest
[0]);
10837 digest
[1] = byte_swap_32 (digest
[1]);
10838 digest
[2] = byte_swap_32 (digest
[2]);
10839 digest
[3] = byte_swap_32 (digest
[3]);
10840 digest
[4] = byte_swap_32 (digest
[4]);
10842 digest
[0] -= SHA1M_A
;
10843 digest
[1] -= SHA1M_B
;
10844 digest
[2] -= SHA1M_C
;
10845 digest
[3] -= SHA1M_D
;
10846 digest
[4] -= SHA1M_E
;
10848 return (PARSER_OK
);
10851 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10853 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10855 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10857 if (c12
& 3) return (PARSER_HASH_VALUE
);
10859 u32
*digest
= (u32
*) hash_buf
->digest
;
10861 salt_t
*salt
= hash_buf
->salt
;
10863 // for ascii_digest
10864 salt
->salt_sign
[0] = input_buf
[0];
10865 salt
->salt_sign
[1] = input_buf
[1];
10867 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10868 | itoa64_to_int (input_buf
[1]) << 6;
10870 salt
->salt_len
= 2;
10872 u8 tmp_buf
[100] = { 0 };
10874 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10876 memcpy (digest
, tmp_buf
, 8);
10880 IP (digest
[0], digest
[1], tt
);
10885 return (PARSER_OK
);
10888 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10890 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10892 u32
*digest
= (u32
*) hash_buf
->digest
;
10894 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10895 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10896 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10897 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10899 digest
[0] = byte_swap_32 (digest
[0]);
10900 digest
[1] = byte_swap_32 (digest
[1]);
10901 digest
[2] = byte_swap_32 (digest
[2]);
10902 digest
[3] = byte_swap_32 (digest
[3]);
10904 digest
[0] -= MD4M_A
;
10905 digest
[1] -= MD4M_B
;
10906 digest
[2] -= MD4M_C
;
10907 digest
[3] -= MD4M_D
;
10909 return (PARSER_OK
);
10912 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10914 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10916 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10920 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10923 u32
*digest
= (u32
*) hash_buf
->digest
;
10925 salt_t
*salt
= hash_buf
->salt
;
10927 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10928 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10929 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10930 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10932 digest
[0] = byte_swap_32 (digest
[0]);
10933 digest
[1] = byte_swap_32 (digest
[1]);
10934 digest
[2] = byte_swap_32 (digest
[2]);
10935 digest
[3] = byte_swap_32 (digest
[3]);
10937 digest
[0] -= MD4M_A
;
10938 digest
[1] -= MD4M_B
;
10939 digest
[2] -= MD4M_C
;
10940 digest
[3] -= MD4M_D
;
10942 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10944 uint salt_len
= input_len
- 32 - 1;
10946 char *salt_buf
= input_buf
+ 32 + 1;
10948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10954 salt
->salt_len
= salt_len
;
10956 return (PARSER_OK
);
10959 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10961 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10963 u32
*digest
= (u32
*) hash_buf
->digest
;
10965 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10966 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10967 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10968 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10970 digest
[0] = byte_swap_32 (digest
[0]);
10971 digest
[1] = byte_swap_32 (digest
[1]);
10972 digest
[2] = byte_swap_32 (digest
[2]);
10973 digest
[3] = byte_swap_32 (digest
[3]);
10975 digest
[0] -= MD5M_A
;
10976 digest
[1] -= MD5M_B
;
10977 digest
[2] -= MD5M_C
;
10978 digest
[3] -= MD5M_D
;
10980 return (PARSER_OK
);
10983 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10985 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10987 u32
*digest
= (u32
*) hash_buf
->digest
;
10989 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10990 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10994 digest
[0] = byte_swap_32 (digest
[0]);
10995 digest
[1] = byte_swap_32 (digest
[1]);
10997 return (PARSER_OK
);
11000 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11002 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11004 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11008 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11011 u32
*digest
= (u32
*) hash_buf
->digest
;
11013 salt_t
*salt
= hash_buf
->salt
;
11015 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11016 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11017 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11018 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11020 digest
[0] = byte_swap_32 (digest
[0]);
11021 digest
[1] = byte_swap_32 (digest
[1]);
11022 digest
[2] = byte_swap_32 (digest
[2]);
11023 digest
[3] = byte_swap_32 (digest
[3]);
11025 digest
[0] -= MD5M_A
;
11026 digest
[1] -= MD5M_B
;
11027 digest
[2] -= MD5M_C
;
11028 digest
[3] -= MD5M_D
;
11030 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11032 uint salt_len
= input_len
- 32 - 1;
11034 char *salt_buf
= input_buf
+ 32 + 1;
11036 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11038 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11040 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11042 salt
->salt_len
= salt_len
;
11044 return (PARSER_OK
);
11047 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11049 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11051 u32
*digest
= (u32
*) hash_buf
->digest
;
11053 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11054 | itoa64_to_int (input_buf
[ 1]) << 6
11055 | itoa64_to_int (input_buf
[ 2]) << 12
11056 | itoa64_to_int (input_buf
[ 3]) << 18;
11057 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11058 | itoa64_to_int (input_buf
[ 5]) << 6
11059 | itoa64_to_int (input_buf
[ 6]) << 12
11060 | itoa64_to_int (input_buf
[ 7]) << 18;
11061 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11062 | itoa64_to_int (input_buf
[ 9]) << 6
11063 | itoa64_to_int (input_buf
[10]) << 12
11064 | itoa64_to_int (input_buf
[11]) << 18;
11065 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11066 | itoa64_to_int (input_buf
[13]) << 6
11067 | itoa64_to_int (input_buf
[14]) << 12
11068 | itoa64_to_int (input_buf
[15]) << 18;
11070 digest
[0] -= MD5M_A
;
11071 digest
[1] -= MD5M_B
;
11072 digest
[2] -= MD5M_C
;
11073 digest
[3] -= MD5M_D
;
11075 digest
[0] &= 0x00ffffff;
11076 digest
[1] &= 0x00ffffff;
11077 digest
[2] &= 0x00ffffff;
11078 digest
[3] &= 0x00ffffff;
11080 return (PARSER_OK
);
11083 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11085 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11087 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11091 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11094 u32
*digest
= (u32
*) hash_buf
->digest
;
11096 salt_t
*salt
= hash_buf
->salt
;
11098 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11099 | itoa64_to_int (input_buf
[ 1]) << 6
11100 | itoa64_to_int (input_buf
[ 2]) << 12
11101 | itoa64_to_int (input_buf
[ 3]) << 18;
11102 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11103 | itoa64_to_int (input_buf
[ 5]) << 6
11104 | itoa64_to_int (input_buf
[ 6]) << 12
11105 | itoa64_to_int (input_buf
[ 7]) << 18;
11106 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11107 | itoa64_to_int (input_buf
[ 9]) << 6
11108 | itoa64_to_int (input_buf
[10]) << 12
11109 | itoa64_to_int (input_buf
[11]) << 18;
11110 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11111 | itoa64_to_int (input_buf
[13]) << 6
11112 | itoa64_to_int (input_buf
[14]) << 12
11113 | itoa64_to_int (input_buf
[15]) << 18;
11115 digest
[0] -= MD5M_A
;
11116 digest
[1] -= MD5M_B
;
11117 digest
[2] -= MD5M_C
;
11118 digest
[3] -= MD5M_D
;
11120 digest
[0] &= 0x00ffffff;
11121 digest
[1] &= 0x00ffffff;
11122 digest
[2] &= 0x00ffffff;
11123 digest
[3] &= 0x00ffffff;
11125 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11127 uint salt_len
= input_len
- 16 - 1;
11129 char *salt_buf
= input_buf
+ 16 + 1;
11131 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11133 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11137 salt
->salt_len
= salt_len
;
11139 return (PARSER_OK
);
11142 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11144 key
[0] = (nthash
[0] >> 0);
11145 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11146 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11147 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11148 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11149 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11150 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11151 key
[7] = (nthash
[6] << 1);
11163 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11165 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11167 u32
*digest
= (u32
*) hash_buf
->digest
;
11169 salt_t
*salt
= hash_buf
->salt
;
11171 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11177 char *user_pos
= input_buf
;
11179 char *unused_pos
= strchr (user_pos
, ':');
11181 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11183 uint user_len
= unused_pos
- user_pos
;
11185 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11189 char *domain_pos
= strchr (unused_pos
, ':');
11191 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11193 uint unused_len
= domain_pos
- unused_pos
;
11195 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11199 char *srvchall_pos
= strchr (domain_pos
, ':');
11201 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11203 uint domain_len
= srvchall_pos
- domain_pos
;
11205 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11209 char *hash_pos
= strchr (srvchall_pos
, ':');
11211 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11213 uint srvchall_len
= hash_pos
- srvchall_pos
;
11215 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11219 char *clichall_pos
= strchr (hash_pos
, ':');
11221 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11223 uint hash_len
= clichall_pos
- hash_pos
;
11225 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11229 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11231 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11234 * store some data for later use
11237 netntlm
->user_len
= user_len
* 2;
11238 netntlm
->domain_len
= domain_len
* 2;
11239 netntlm
->srvchall_len
= srvchall_len
/ 2;
11240 netntlm
->clichall_len
= clichall_len
/ 2;
11242 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11243 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11246 * handle username and domainname
11249 for (uint i
= 0; i
< user_len
; i
++)
11251 *userdomain_ptr
++ = user_pos
[i
];
11252 *userdomain_ptr
++ = 0;
11255 for (uint i
= 0; i
< domain_len
; i
++)
11257 *userdomain_ptr
++ = domain_pos
[i
];
11258 *userdomain_ptr
++ = 0;
11262 * handle server challenge encoding
11265 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11267 const char p0
= srvchall_pos
[i
+ 0];
11268 const char p1
= srvchall_pos
[i
+ 1];
11270 *chall_ptr
++ = hex_convert (p1
) << 0
11271 | hex_convert (p0
) << 4;
11275 * handle client challenge encoding
11278 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11280 const char p0
= clichall_pos
[i
+ 0];
11281 const char p1
= clichall_pos
[i
+ 1];
11283 *chall_ptr
++ = hex_convert (p1
) << 0
11284 | hex_convert (p0
) << 4;
11291 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11293 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11295 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11297 salt
->salt_len
= salt_len
;
11299 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11300 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11301 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11302 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11304 digest
[0] = byte_swap_32 (digest
[0]);
11305 digest
[1] = byte_swap_32 (digest
[1]);
11306 digest
[2] = byte_swap_32 (digest
[2]);
11307 digest
[3] = byte_swap_32 (digest
[3]);
11309 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11311 uint digest_tmp
[2] = { 0 };
11313 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11314 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11316 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11317 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11319 /* special case 2: ESS */
11321 if (srvchall_len
== 48)
11323 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11325 uint w
[16] = { 0 };
11327 w
[ 0] = netntlm
->chall_buf
[6];
11328 w
[ 1] = netntlm
->chall_buf
[7];
11329 w
[ 2] = netntlm
->chall_buf
[0];
11330 w
[ 3] = netntlm
->chall_buf
[1];
11334 uint dgst
[4] = { 0 };
11343 salt
->salt_buf
[0] = dgst
[0];
11344 salt
->salt_buf
[1] = dgst
[1];
11348 /* precompute netntlmv1 exploit start */
11350 for (uint i
= 0; i
< 0x10000; i
++)
11352 uint key_md4
[2] = { i
, 0 };
11353 uint key_des
[2] = { 0, 0 };
11355 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11357 uint Kc
[16] = { 0 };
11358 uint Kd
[16] = { 0 };
11360 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11362 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11364 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11366 if (data3
[0] != digest_tmp
[0]) continue;
11367 if (data3
[1] != digest_tmp
[1]) continue;
11369 salt
->salt_buf
[2] = i
;
11371 salt
->salt_len
= 24;
11376 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11377 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11379 /* precompute netntlmv1 exploit stop */
11383 IP (digest
[0], digest
[1], tt
);
11384 IP (digest
[2], digest
[3], tt
);
11386 digest
[0] = rotr32 (digest
[0], 29);
11387 digest
[1] = rotr32 (digest
[1], 29);
11388 digest
[2] = rotr32 (digest
[2], 29);
11389 digest
[3] = rotr32 (digest
[3], 29);
11391 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11393 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11394 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11396 return (PARSER_OK
);
11399 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11401 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11403 u32
*digest
= (u32
*) hash_buf
->digest
;
11405 salt_t
*salt
= hash_buf
->salt
;
11407 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11413 char *user_pos
= input_buf
;
11415 char *unused_pos
= strchr (user_pos
, ':');
11417 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11419 uint user_len
= unused_pos
- user_pos
;
11421 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11425 char *domain_pos
= strchr (unused_pos
, ':');
11427 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11429 uint unused_len
= domain_pos
- unused_pos
;
11431 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11435 char *srvchall_pos
= strchr (domain_pos
, ':');
11437 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11439 uint domain_len
= srvchall_pos
- domain_pos
;
11441 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11445 char *hash_pos
= strchr (srvchall_pos
, ':');
11447 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11449 uint srvchall_len
= hash_pos
- srvchall_pos
;
11451 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11455 char *clichall_pos
= strchr (hash_pos
, ':');
11457 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11459 uint hash_len
= clichall_pos
- hash_pos
;
11461 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11465 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11467 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11469 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11472 * store some data for later use
11475 netntlm
->user_len
= user_len
* 2;
11476 netntlm
->domain_len
= domain_len
* 2;
11477 netntlm
->srvchall_len
= srvchall_len
/ 2;
11478 netntlm
->clichall_len
= clichall_len
/ 2;
11480 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11481 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11484 * handle username and domainname
11487 for (uint i
= 0; i
< user_len
; i
++)
11489 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11490 *userdomain_ptr
++ = 0;
11493 for (uint i
= 0; i
< domain_len
; i
++)
11495 *userdomain_ptr
++ = domain_pos
[i
];
11496 *userdomain_ptr
++ = 0;
11499 *userdomain_ptr
++ = 0x80;
11502 * handle server challenge encoding
11505 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11507 const char p0
= srvchall_pos
[i
+ 0];
11508 const char p1
= srvchall_pos
[i
+ 1];
11510 *chall_ptr
++ = hex_convert (p1
) << 0
11511 | hex_convert (p0
) << 4;
11515 * handle client challenge encoding
11518 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11520 const char p0
= clichall_pos
[i
+ 0];
11521 const char p1
= clichall_pos
[i
+ 1];
11523 *chall_ptr
++ = hex_convert (p1
) << 0
11524 | hex_convert (p0
) << 4;
11527 *chall_ptr
++ = 0x80;
11530 * handle hash itself
11533 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11534 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11535 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11536 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11538 digest
[0] = byte_swap_32 (digest
[0]);
11539 digest
[1] = byte_swap_32 (digest
[1]);
11540 digest
[2] = byte_swap_32 (digest
[2]);
11541 digest
[3] = byte_swap_32 (digest
[3]);
11544 * reuse challange data as salt_buf, its the buffer that is most likely unique
11547 salt
->salt_buf
[0] = 0;
11548 salt
->salt_buf
[1] = 0;
11549 salt
->salt_buf
[2] = 0;
11550 salt
->salt_buf
[3] = 0;
11551 salt
->salt_buf
[4] = 0;
11552 salt
->salt_buf
[5] = 0;
11553 salt
->salt_buf
[6] = 0;
11554 salt
->salt_buf
[7] = 0;
11558 uptr
= (uint
*) netntlm
->userdomain_buf
;
11560 for (uint i
= 0; i
< 16; i
+= 16)
11562 md5_64 (uptr
, salt
->salt_buf
);
11565 uptr
= (uint
*) netntlm
->chall_buf
;
11567 for (uint i
= 0; i
< 256; i
+= 16)
11569 md5_64 (uptr
, salt
->salt_buf
);
11572 salt
->salt_len
= 16;
11574 return (PARSER_OK
);
11577 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11579 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11581 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11585 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11588 u32
*digest
= (u32
*) hash_buf
->digest
;
11590 salt_t
*salt
= hash_buf
->salt
;
11592 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11593 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11594 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11595 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11597 digest
[0] = byte_swap_32 (digest
[0]);
11598 digest
[1] = byte_swap_32 (digest
[1]);
11599 digest
[2] = byte_swap_32 (digest
[2]);
11600 digest
[3] = byte_swap_32 (digest
[3]);
11602 digest
[0] -= MD5M_A
;
11603 digest
[1] -= MD5M_B
;
11604 digest
[2] -= MD5M_C
;
11605 digest
[3] -= MD5M_D
;
11607 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11609 uint salt_len
= input_len
- 32 - 1;
11611 char *salt_buf
= input_buf
+ 32 + 1;
11613 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11615 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11617 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11619 salt
->salt_len
= salt_len
;
11621 return (PARSER_OK
);
11624 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11626 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11628 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11632 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11635 u32
*digest
= (u32
*) hash_buf
->digest
;
11637 salt_t
*salt
= hash_buf
->salt
;
11639 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11640 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11641 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11642 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11644 digest
[0] = byte_swap_32 (digest
[0]);
11645 digest
[1] = byte_swap_32 (digest
[1]);
11646 digest
[2] = byte_swap_32 (digest
[2]);
11647 digest
[3] = byte_swap_32 (digest
[3]);
11649 digest
[0] -= MD5M_A
;
11650 digest
[1] -= MD5M_B
;
11651 digest
[2] -= MD5M_C
;
11652 digest
[3] -= MD5M_D
;
11654 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11656 uint salt_len
= input_len
- 32 - 1;
11658 char *salt_buf
= input_buf
+ 32 + 1;
11660 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11662 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11664 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11666 salt
->salt_len
= salt_len
;
11668 return (PARSER_OK
);
11671 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11675 u32
*digest
= (u32
*) hash_buf
->digest
;
11677 salt_t
*salt
= hash_buf
->salt
;
11679 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11680 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11681 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11682 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11684 digest
[0] = byte_swap_32 (digest
[0]);
11685 digest
[1] = byte_swap_32 (digest
[1]);
11686 digest
[2] = byte_swap_32 (digest
[2]);
11687 digest
[3] = byte_swap_32 (digest
[3]);
11689 digest
[0] -= MD5M_A
;
11690 digest
[1] -= MD5M_B
;
11691 digest
[2] -= MD5M_C
;
11692 digest
[3] -= MD5M_D
;
11695 * This is a virtual salt. While the algorithm is basically not salted
11696 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11697 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11700 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11702 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11704 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11706 salt
->salt_len
= salt_len
;
11708 return (PARSER_OK
);
11711 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11713 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11715 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11719 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11722 u32
*digest
= (u32
*) hash_buf
->digest
;
11724 salt_t
*salt
= hash_buf
->salt
;
11726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11731 digest
[0] = byte_swap_32 (digest
[0]);
11732 digest
[1] = byte_swap_32 (digest
[1]);
11733 digest
[2] = byte_swap_32 (digest
[2]);
11734 digest
[3] = byte_swap_32 (digest
[3]);
11736 digest
[0] -= MD5M_A
;
11737 digest
[1] -= MD5M_B
;
11738 digest
[2] -= MD5M_C
;
11739 digest
[3] -= MD5M_D
;
11741 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11743 uint salt_len
= input_len
- 32 - 1;
11745 char *salt_buf
= input_buf
+ 32 + 1;
11747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11749 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11753 salt
->salt_len
= salt_len
;
11755 return (PARSER_OK
);
11758 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11760 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11762 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11766 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11769 u32
*digest
= (u32
*) hash_buf
->digest
;
11771 salt_t
*salt
= hash_buf
->salt
;
11773 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11774 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11775 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11776 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11778 digest
[0] = byte_swap_32 (digest
[0]);
11779 digest
[1] = byte_swap_32 (digest
[1]);
11780 digest
[2] = byte_swap_32 (digest
[2]);
11781 digest
[3] = byte_swap_32 (digest
[3]);
11783 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11785 uint salt_len
= input_len
- 32 - 1;
11787 char *salt_buf
= input_buf
+ 32 + 1;
11789 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11791 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11793 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11795 salt
->salt_len
= salt_len
;
11797 return (PARSER_OK
);
11800 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11802 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11804 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11808 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11811 u32
*digest
= (u32
*) hash_buf
->digest
;
11813 salt_t
*salt
= hash_buf
->salt
;
11815 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11816 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11817 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11818 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11820 digest
[0] = byte_swap_32 (digest
[0]);
11821 digest
[1] = byte_swap_32 (digest
[1]);
11822 digest
[2] = byte_swap_32 (digest
[2]);
11823 digest
[3] = byte_swap_32 (digest
[3]);
11825 digest
[0] -= MD4M_A
;
11826 digest
[1] -= MD4M_B
;
11827 digest
[2] -= MD4M_C
;
11828 digest
[3] -= MD4M_D
;
11830 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11832 uint salt_len
= input_len
- 32 - 1;
11834 char *salt_buf
= input_buf
+ 32 + 1;
11836 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11838 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11840 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11842 salt
->salt_len
= salt_len
;
11844 return (PARSER_OK
);
11847 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11849 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11851 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11855 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11858 u32
*digest
= (u32
*) hash_buf
->digest
;
11860 salt_t
*salt
= hash_buf
->salt
;
11862 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11863 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11864 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11865 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11867 digest
[0] = byte_swap_32 (digest
[0]);
11868 digest
[1] = byte_swap_32 (digest
[1]);
11869 digest
[2] = byte_swap_32 (digest
[2]);
11870 digest
[3] = byte_swap_32 (digest
[3]);
11872 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11874 uint salt_len
= input_len
- 32 - 1;
11876 char *salt_buf
= input_buf
+ 32 + 1;
11878 uint salt_pc_block
[16] = { 0 };
11880 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11882 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11884 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11886 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11888 salt_pc_block
[14] = salt_len
* 8;
11890 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11892 md5_64 (salt_pc_block
, salt_pc_digest
);
11894 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11895 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11896 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11897 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11899 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11901 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11903 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11905 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11906 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11907 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11908 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11910 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11912 return (PARSER_OK
);
11915 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11917 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11919 u32
*digest
= (u32
*) hash_buf
->digest
;
11921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11925 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11927 digest
[0] -= SHA1M_A
;
11928 digest
[1] -= SHA1M_B
;
11929 digest
[2] -= SHA1M_C
;
11930 digest
[3] -= SHA1M_D
;
11931 digest
[4] -= SHA1M_E
;
11933 return (PARSER_OK
);
11936 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11938 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11940 u32
*digest
= (u32
*) hash_buf
->digest
;
11942 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11943 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11944 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11945 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11946 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11948 return (PARSER_OK
);
11951 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11953 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11955 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11957 u32
*digest
= (u32
*) hash_buf
->digest
;
11961 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11962 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11963 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11964 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11965 digest
[4] = 0x00000000;
11967 return (PARSER_OK
);
11970 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11972 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11974 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11978 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11981 u32
*digest
= (u32
*) hash_buf
->digest
;
11983 salt_t
*salt
= hash_buf
->salt
;
11985 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11986 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11987 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11988 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11989 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11991 digest
[0] -= SHA1M_A
;
11992 digest
[1] -= SHA1M_B
;
11993 digest
[2] -= SHA1M_C
;
11994 digest
[3] -= SHA1M_D
;
11995 digest
[4] -= SHA1M_E
;
11997 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11999 uint salt_len
= input_len
- 40 - 1;
12001 char *salt_buf
= input_buf
+ 40 + 1;
12003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12009 salt
->salt_len
= salt_len
;
12011 return (PARSER_OK
);
12014 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12016 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12018 u32
*digest
= (u32
*) hash_buf
->digest
;
12020 salt_t
*salt
= hash_buf
->salt
;
12022 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12024 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12025 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12026 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12027 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12028 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12030 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12032 uint salt_len
= input_len
- 40 - 1;
12034 char *salt_buf
= input_buf
+ 40 + 1;
12036 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12038 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12040 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12042 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12045 pstoken
->salt_len
= salt_len
/ 2;
12047 /* some fake salt for the sorting mechanisms */
12049 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12050 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12051 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12052 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12053 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12054 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12055 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12056 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12058 salt
->salt_len
= 32;
12060 /* we need to check if we can precompute some of the data --
12061 this is possible since the scheme is badly designed */
12063 pstoken
->pc_digest
[0] = SHA1M_A
;
12064 pstoken
->pc_digest
[1] = SHA1M_B
;
12065 pstoken
->pc_digest
[2] = SHA1M_C
;
12066 pstoken
->pc_digest
[3] = SHA1M_D
;
12067 pstoken
->pc_digest
[4] = SHA1M_E
;
12069 pstoken
->pc_offset
= 0;
12071 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12075 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12076 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12077 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12078 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12079 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12080 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12081 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12082 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12083 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12084 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12085 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12086 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12087 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12088 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12089 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12090 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12092 sha1_64 (w
, pstoken
->pc_digest
);
12094 pstoken
->pc_offset
+= 16;
12097 return (PARSER_OK
);
12100 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12102 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12104 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12106 u32
*digest
= (u32
*) hash_buf
->digest
;
12108 u8 tmp_buf
[100] = { 0 };
12110 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12112 memcpy (digest
, tmp_buf
, 20);
12114 digest
[0] = byte_swap_32 (digest
[0]);
12115 digest
[1] = byte_swap_32 (digest
[1]);
12116 digest
[2] = byte_swap_32 (digest
[2]);
12117 digest
[3] = byte_swap_32 (digest
[3]);
12118 digest
[4] = byte_swap_32 (digest
[4]);
12120 digest
[0] -= SHA1M_A
;
12121 digest
[1] -= SHA1M_B
;
12122 digest
[2] -= SHA1M_C
;
12123 digest
[3] -= SHA1M_D
;
12124 digest
[4] -= SHA1M_E
;
12126 return (PARSER_OK
);
12129 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12131 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12133 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12135 u32
*digest
= (u32
*) hash_buf
->digest
;
12137 salt_t
*salt
= hash_buf
->salt
;
12139 u8 tmp_buf
[100] = { 0 };
12141 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12143 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12145 memcpy (digest
, tmp_buf
, 20);
12147 int salt_len
= tmp_len
- 20;
12149 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12151 salt
->salt_len
= salt_len
;
12153 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12155 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12157 char *ptr
= (char *) salt
->salt_buf
;
12159 ptr
[salt
->salt_len
] = 0x80;
12162 digest
[0] = byte_swap_32 (digest
[0]);
12163 digest
[1] = byte_swap_32 (digest
[1]);
12164 digest
[2] = byte_swap_32 (digest
[2]);
12165 digest
[3] = byte_swap_32 (digest
[3]);
12166 digest
[4] = byte_swap_32 (digest
[4]);
12168 digest
[0] -= SHA1M_A
;
12169 digest
[1] -= SHA1M_B
;
12170 digest
[2] -= SHA1M_C
;
12171 digest
[3] -= SHA1M_D
;
12172 digest
[4] -= SHA1M_E
;
12174 return (PARSER_OK
);
12177 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12179 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12181 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12183 u32
*digest
= (u32
*) hash_buf
->digest
;
12185 salt_t
*salt
= hash_buf
->salt
;
12187 char *salt_buf
= input_buf
+ 6;
12191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12193 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12197 salt
->salt_len
= salt_len
;
12199 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12201 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12202 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12203 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12204 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12205 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12207 digest
[0] -= SHA1M_A
;
12208 digest
[1] -= SHA1M_B
;
12209 digest
[2] -= SHA1M_C
;
12210 digest
[3] -= SHA1M_D
;
12211 digest
[4] -= SHA1M_E
;
12213 return (PARSER_OK
);
12216 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12218 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12220 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12222 u32
*digest
= (u32
*) hash_buf
->digest
;
12224 salt_t
*salt
= hash_buf
->salt
;
12226 char *salt_buf
= input_buf
+ 6;
12230 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12232 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12234 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12236 salt
->salt_len
= salt_len
;
12238 char *hash_pos
= input_buf
+ 6 + 8;
12240 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12241 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12242 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12243 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12244 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12246 digest
[0] -= SHA1M_A
;
12247 digest
[1] -= SHA1M_B
;
12248 digest
[2] -= SHA1M_C
;
12249 digest
[3] -= SHA1M_D
;
12250 digest
[4] -= SHA1M_E
;
12252 return (PARSER_OK
);
12255 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12257 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12259 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12261 u64
*digest
= (u64
*) hash_buf
->digest
;
12263 salt_t
*salt
= hash_buf
->salt
;
12265 char *salt_buf
= input_buf
+ 6;
12269 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12271 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12273 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12275 salt
->salt_len
= salt_len
;
12277 char *hash_pos
= input_buf
+ 6 + 8;
12279 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12280 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12281 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12282 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12283 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12284 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12285 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12286 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12288 digest
[0] -= SHA512M_A
;
12289 digest
[1] -= SHA512M_B
;
12290 digest
[2] -= SHA512M_C
;
12291 digest
[3] -= SHA512M_D
;
12292 digest
[4] -= SHA512M_E
;
12293 digest
[5] -= SHA512M_F
;
12294 digest
[6] -= SHA512M_G
;
12295 digest
[7] -= SHA512M_H
;
12297 return (PARSER_OK
);
12300 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12302 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12304 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12308 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12311 u32
*digest
= (u32
*) hash_buf
->digest
;
12313 salt_t
*salt
= hash_buf
->salt
;
12315 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12316 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12320 digest
[0] = byte_swap_32 (digest
[0]);
12321 digest
[1] = byte_swap_32 (digest
[1]);
12323 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12325 uint salt_len
= input_len
- 16 - 1;
12327 char *salt_buf
= input_buf
+ 16 + 1;
12329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12335 salt
->salt_len
= salt_len
;
12337 return (PARSER_OK
);
12340 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12342 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12344 u32
*digest
= (u32
*) hash_buf
->digest
;
12346 salt_t
*salt
= hash_buf
->salt
;
12348 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12349 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12350 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12351 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12352 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12354 digest
[0] -= SHA1M_A
;
12355 digest
[1] -= SHA1M_B
;
12356 digest
[2] -= SHA1M_C
;
12357 digest
[3] -= SHA1M_D
;
12358 digest
[4] -= SHA1M_E
;
12360 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12362 uint salt_len
= input_len
- 40 - 1;
12364 char *salt_buf
= input_buf
+ 40 + 1;
12366 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12368 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12370 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12372 salt
->salt_len
= salt_len
;
12374 return (PARSER_OK
);
12377 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12381 u32
*digest
= (u32
*) hash_buf
->digest
;
12383 salt_t
*salt
= hash_buf
->salt
;
12385 char *hash_pos
= input_buf
;
12387 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12388 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12389 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12390 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12391 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12392 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12393 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12394 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12395 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12396 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12397 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12398 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12399 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12400 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12401 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12402 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12404 char *salt_pos
= input_buf
+ 128;
12406 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12407 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12408 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12409 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12411 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12412 salt
->salt_len
= 16;
12414 return (PARSER_OK
);
12417 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12419 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12421 u32
*digest
= (u32
*) hash_buf
->digest
;
12423 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12424 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12425 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12426 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12427 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12428 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12429 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12430 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12432 digest
[0] -= SHA256M_A
;
12433 digest
[1] -= SHA256M_B
;
12434 digest
[2] -= SHA256M_C
;
12435 digest
[3] -= SHA256M_D
;
12436 digest
[4] -= SHA256M_E
;
12437 digest
[5] -= SHA256M_F
;
12438 digest
[6] -= SHA256M_G
;
12439 digest
[7] -= SHA256M_H
;
12441 return (PARSER_OK
);
12444 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12446 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12448 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12452 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12455 u32
*digest
= (u32
*) hash_buf
->digest
;
12457 salt_t
*salt
= hash_buf
->salt
;
12459 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12460 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12461 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12462 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12463 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12464 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12465 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12466 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12468 digest
[0] -= SHA256M_A
;
12469 digest
[1] -= SHA256M_B
;
12470 digest
[2] -= SHA256M_C
;
12471 digest
[3] -= SHA256M_D
;
12472 digest
[4] -= SHA256M_E
;
12473 digest
[5] -= SHA256M_F
;
12474 digest
[6] -= SHA256M_G
;
12475 digest
[7] -= SHA256M_H
;
12477 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12479 uint salt_len
= input_len
- 64 - 1;
12481 char *salt_buf
= input_buf
+ 64 + 1;
12483 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12485 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12487 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12489 salt
->salt_len
= salt_len
;
12491 return (PARSER_OK
);
12494 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12496 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12498 u64
*digest
= (u64
*) hash_buf
->digest
;
12500 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12501 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12502 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12503 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12504 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12505 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12509 digest
[0] -= SHA384M_A
;
12510 digest
[1] -= SHA384M_B
;
12511 digest
[2] -= SHA384M_C
;
12512 digest
[3] -= SHA384M_D
;
12513 digest
[4] -= SHA384M_E
;
12514 digest
[5] -= SHA384M_F
;
12518 return (PARSER_OK
);
12521 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12523 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12525 u64
*digest
= (u64
*) hash_buf
->digest
;
12527 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12528 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12529 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12530 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12531 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12532 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12533 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12534 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12536 digest
[0] -= SHA512M_A
;
12537 digest
[1] -= SHA512M_B
;
12538 digest
[2] -= SHA512M_C
;
12539 digest
[3] -= SHA512M_D
;
12540 digest
[4] -= SHA512M_E
;
12541 digest
[5] -= SHA512M_F
;
12542 digest
[6] -= SHA512M_G
;
12543 digest
[7] -= SHA512M_H
;
12545 return (PARSER_OK
);
12548 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12550 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12552 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12556 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12559 u64
*digest
= (u64
*) hash_buf
->digest
;
12561 salt_t
*salt
= hash_buf
->salt
;
12563 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12564 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12565 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12566 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12567 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12568 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12569 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12570 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12572 digest
[0] -= SHA512M_A
;
12573 digest
[1] -= SHA512M_B
;
12574 digest
[2] -= SHA512M_C
;
12575 digest
[3] -= SHA512M_D
;
12576 digest
[4] -= SHA512M_E
;
12577 digest
[5] -= SHA512M_F
;
12578 digest
[6] -= SHA512M_G
;
12579 digest
[7] -= SHA512M_H
;
12581 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12583 uint salt_len
= input_len
- 128 - 1;
12585 char *salt_buf
= input_buf
+ 128 + 1;
12587 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12589 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12591 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12593 salt
->salt_len
= salt_len
;
12595 return (PARSER_OK
);
12598 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12600 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12602 u64
*digest
= (u64
*) hash_buf
->digest
;
12604 salt_t
*salt
= hash_buf
->salt
;
12606 char *salt_pos
= input_buf
+ 3;
12608 uint iterations_len
= 0;
12610 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12614 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12616 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12617 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12621 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12625 iterations_len
+= 8;
12629 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12632 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12634 char *hash_pos
= strchr (salt_pos
, '$');
12636 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12638 uint salt_len
= hash_pos
- salt_pos
;
12640 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12642 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12644 salt
->salt_len
= salt_len
;
12648 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12650 return (PARSER_OK
);
12653 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12655 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12657 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12659 u64
*digest
= (u64
*) hash_buf
->digest
;
12661 salt_t
*salt
= hash_buf
->salt
;
12663 uint keccak_mdlen
= input_len
/ 2;
12665 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12667 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12669 digest
[i
] = byte_swap_64 (digest
[i
]);
12672 salt
->keccak_mdlen
= keccak_mdlen
;
12674 return (PARSER_OK
);
12677 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12679 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12681 u32
*digest
= (u32
*) hash_buf
->digest
;
12683 salt_t
*salt
= hash_buf
->salt
;
12685 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12688 * Parse that strange long line
12693 size_t in_len
[9] = { 0 };
12695 in_off
[0] = strtok (input_buf
, ":");
12697 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12699 in_len
[0] = strlen (in_off
[0]);
12703 for (i
= 1; i
< 9; i
++)
12705 in_off
[i
] = strtok (NULL
, ":");
12707 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12709 in_len
[i
] = strlen (in_off
[i
]);
12712 char *ptr
= (char *) ikepsk
->msg_buf
;
12714 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12715 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12716 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12717 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12718 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12719 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12723 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12725 ptr
= (char *) ikepsk
->nr_buf
;
12727 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12728 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12732 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12735 * Store to database
12740 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12741 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12742 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12743 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12745 digest
[0] = byte_swap_32 (digest
[0]);
12746 digest
[1] = byte_swap_32 (digest
[1]);
12747 digest
[2] = byte_swap_32 (digest
[2]);
12748 digest
[3] = byte_swap_32 (digest
[3]);
12750 salt
->salt_len
= 32;
12752 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12753 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12754 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12755 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12756 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12757 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12758 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12759 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12761 return (PARSER_OK
);
12764 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12766 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12768 u32
*digest
= (u32
*) hash_buf
->digest
;
12770 salt_t
*salt
= hash_buf
->salt
;
12772 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12775 * Parse that strange long line
12780 size_t in_len
[9] = { 0 };
12782 in_off
[0] = strtok (input_buf
, ":");
12784 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12786 in_len
[0] = strlen (in_off
[0]);
12790 for (i
= 1; i
< 9; i
++)
12792 in_off
[i
] = strtok (NULL
, ":");
12794 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12796 in_len
[i
] = strlen (in_off
[i
]);
12799 char *ptr
= (char *) ikepsk
->msg_buf
;
12801 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12802 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12803 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12804 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12805 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12806 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12810 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12812 ptr
= (char *) ikepsk
->nr_buf
;
12814 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12815 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12819 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12822 * Store to database
12827 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12828 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12829 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12830 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12831 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12833 salt
->salt_len
= 32;
12835 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12836 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12837 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12838 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12839 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12840 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12841 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12842 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12844 return (PARSER_OK
);
12847 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12849 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12851 u32
*digest
= (u32
*) hash_buf
->digest
;
12853 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12854 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12855 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12856 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12857 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12859 digest
[0] = byte_swap_32 (digest
[0]);
12860 digest
[1] = byte_swap_32 (digest
[1]);
12861 digest
[2] = byte_swap_32 (digest
[2]);
12862 digest
[3] = byte_swap_32 (digest
[3]);
12863 digest
[4] = byte_swap_32 (digest
[4]);
12865 return (PARSER_OK
);
12868 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12870 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12872 u32
*digest
= (u32
*) hash_buf
->digest
;
12874 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12875 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12876 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12877 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12878 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12879 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12880 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12881 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12882 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12883 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12884 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12885 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12886 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12887 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12888 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12889 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12891 return (PARSER_OK
);
12894 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12896 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12898 u32
*digest
= (u32
*) hash_buf
->digest
;
12900 salt_t
*salt
= hash_buf
->salt
;
12902 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12903 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12904 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12905 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12906 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12908 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12910 uint salt_len
= input_len
- 40 - 1;
12912 char *salt_buf
= input_buf
+ 40 + 1;
12914 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12916 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12918 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12920 salt
->salt_len
= salt_len
;
12922 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12924 return (PARSER_OK
);
12927 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12929 u32
*digest
= (u32
*) hash_buf
->digest
;
12931 salt_t
*salt
= hash_buf
->salt
;
12933 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12935 if (input_len
== 0)
12937 log_error ("TrueCrypt container not specified");
12942 FILE *fp
= fopen (input_buf
, "rb");
12946 log_error ("%s: %s", input_buf
, strerror (errno
));
12951 char buf
[512] = { 0 };
12953 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12957 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12959 memcpy (tc
->salt_buf
, buf
, 64);
12961 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12963 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12965 salt
->salt_len
= 4;
12967 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12969 tc
->signature
= 0x45555254; // "TRUE"
12971 digest
[0] = tc
->data_buf
[0];
12973 return (PARSER_OK
);
12976 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12978 u32
*digest
= (u32
*) hash_buf
->digest
;
12980 salt_t
*salt
= hash_buf
->salt
;
12982 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12984 if (input_len
== 0)
12986 log_error ("TrueCrypt container not specified");
12991 FILE *fp
= fopen (input_buf
, "rb");
12995 log_error ("%s: %s", input_buf
, strerror (errno
));
13000 char buf
[512] = { 0 };
13002 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13006 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13008 memcpy (tc
->salt_buf
, buf
, 64);
13010 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13012 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13014 salt
->salt_len
= 4;
13016 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13018 tc
->signature
= 0x45555254; // "TRUE"
13020 digest
[0] = tc
->data_buf
[0];
13022 return (PARSER_OK
);
13025 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13027 u32
*digest
= (u32
*) hash_buf
->digest
;
13029 salt_t
*salt
= hash_buf
->salt
;
13031 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13033 if (input_len
== 0)
13035 log_error ("VeraCrypt container not specified");
13040 FILE *fp
= fopen (input_buf
, "rb");
13044 log_error ("%s: %s", input_buf
, strerror (errno
));
13049 char buf
[512] = { 0 };
13051 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13055 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13057 memcpy (tc
->salt_buf
, buf
, 64);
13059 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13061 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13063 salt
->salt_len
= 4;
13065 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13067 tc
->signature
= 0x41524556; // "VERA"
13069 digest
[0] = tc
->data_buf
[0];
13071 return (PARSER_OK
);
13074 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13076 u32
*digest
= (u32
*) hash_buf
->digest
;
13078 salt_t
*salt
= hash_buf
->salt
;
13080 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13082 if (input_len
== 0)
13084 log_error ("VeraCrypt container not specified");
13089 FILE *fp
= fopen (input_buf
, "rb");
13093 log_error ("%s: %s", input_buf
, strerror (errno
));
13098 char buf
[512] = { 0 };
13100 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13104 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13106 memcpy (tc
->salt_buf
, buf
, 64);
13108 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13110 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13112 salt
->salt_len
= 4;
13114 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13116 tc
->signature
= 0x41524556; // "VERA"
13118 digest
[0] = tc
->data_buf
[0];
13120 return (PARSER_OK
);
13123 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13125 u32
*digest
= (u32
*) hash_buf
->digest
;
13127 salt_t
*salt
= hash_buf
->salt
;
13129 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13131 if (input_len
== 0)
13133 log_error ("VeraCrypt container not specified");
13138 FILE *fp
= fopen (input_buf
, "rb");
13142 log_error ("%s: %s", input_buf
, strerror (errno
));
13147 char buf
[512] = { 0 };
13149 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13153 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13155 memcpy (tc
->salt_buf
, buf
, 64);
13157 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13159 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13161 salt
->salt_len
= 4;
13163 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13165 tc
->signature
= 0x41524556; // "VERA"
13167 digest
[0] = tc
->data_buf
[0];
13169 return (PARSER_OK
);
13172 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13174 u32
*digest
= (u32
*) hash_buf
->digest
;
13176 salt_t
*salt
= hash_buf
->salt
;
13178 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13180 if (input_len
== 0)
13182 log_error ("VeraCrypt container not specified");
13187 FILE *fp
= fopen (input_buf
, "rb");
13191 log_error ("%s: %s", input_buf
, strerror (errno
));
13196 char buf
[512] = { 0 };
13198 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13202 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13204 memcpy (tc
->salt_buf
, buf
, 64);
13206 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13208 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13210 salt
->salt_len
= 4;
13212 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13214 tc
->signature
= 0x41524556; // "VERA"
13216 digest
[0] = tc
->data_buf
[0];
13218 return (PARSER_OK
);
13221 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13223 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13225 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13227 u32
*digest
= (u32
*) hash_buf
->digest
;
13229 salt_t
*salt
= hash_buf
->salt
;
13231 char *salt_pos
= input_buf
+ 6;
13233 char *hash_pos
= strchr (salt_pos
, '$');
13235 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13237 uint salt_len
= hash_pos
- salt_pos
;
13239 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13241 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13243 salt
->salt_len
= salt_len
;
13245 salt
->salt_iter
= 1000;
13249 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13251 return (PARSER_OK
);
13254 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13256 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13258 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13260 u32
*digest
= (u32
*) hash_buf
->digest
;
13262 salt_t
*salt
= hash_buf
->salt
;
13264 char *iter_pos
= input_buf
+ 7;
13266 char *salt_pos
= strchr (iter_pos
, '$');
13268 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13272 char *hash_pos
= strchr (salt_pos
, '$');
13274 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13276 uint salt_len
= hash_pos
- salt_pos
;
13278 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13280 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13282 salt
->salt_len
= salt_len
;
13284 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13286 salt
->salt_sign
[0] = atoi (salt_iter
);
13288 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13292 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13294 digest
[0] = byte_swap_32 (digest
[0]);
13295 digest
[1] = byte_swap_32 (digest
[1]);
13296 digest
[2] = byte_swap_32 (digest
[2]);
13297 digest
[3] = byte_swap_32 (digest
[3]);
13298 digest
[4] = byte_swap_32 (digest
[4]);
13300 return (PARSER_OK
);
13303 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13305 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13307 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13309 u32
*digest
= (u32
*) hash_buf
->digest
;
13311 salt_t
*salt
= hash_buf
->salt
;
13313 char *iter_pos
= input_buf
+ 9;
13315 char *salt_pos
= strchr (iter_pos
, '$');
13317 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13321 char *hash_pos
= strchr (salt_pos
, '$');
13323 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13325 uint salt_len
= hash_pos
- salt_pos
;
13327 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13329 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13331 salt
->salt_len
= salt_len
;
13333 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13335 salt
->salt_sign
[0] = atoi (salt_iter
);
13337 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13341 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13343 digest
[0] = byte_swap_32 (digest
[0]);
13344 digest
[1] = byte_swap_32 (digest
[1]);
13345 digest
[2] = byte_swap_32 (digest
[2]);
13346 digest
[3] = byte_swap_32 (digest
[3]);
13347 digest
[4] = byte_swap_32 (digest
[4]);
13348 digest
[5] = byte_swap_32 (digest
[5]);
13349 digest
[6] = byte_swap_32 (digest
[6]);
13350 digest
[7] = byte_swap_32 (digest
[7]);
13352 return (PARSER_OK
);
13355 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13357 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13359 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13361 u64
*digest
= (u64
*) hash_buf
->digest
;
13363 salt_t
*salt
= hash_buf
->salt
;
13365 char *iter_pos
= input_buf
+ 9;
13367 char *salt_pos
= strchr (iter_pos
, '$');
13369 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13373 char *hash_pos
= strchr (salt_pos
, '$');
13375 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13377 uint salt_len
= hash_pos
- salt_pos
;
13379 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13381 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13383 salt
->salt_len
= salt_len
;
13385 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13387 salt
->salt_sign
[0] = atoi (salt_iter
);
13389 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13393 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13395 digest
[0] = byte_swap_64 (digest
[0]);
13396 digest
[1] = byte_swap_64 (digest
[1]);
13397 digest
[2] = byte_swap_64 (digest
[2]);
13398 digest
[3] = byte_swap_64 (digest
[3]);
13399 digest
[4] = byte_swap_64 (digest
[4]);
13400 digest
[5] = byte_swap_64 (digest
[5]);
13401 digest
[6] = byte_swap_64 (digest
[6]);
13402 digest
[7] = byte_swap_64 (digest
[7]);
13404 return (PARSER_OK
);
13407 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13409 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13411 u32
*digest
= (u32
*) hash_buf
->digest
;
13413 salt_t
*salt
= hash_buf
->salt
;
13415 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13421 char *iterations_pos
= input_buf
;
13423 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13425 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13427 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13429 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13433 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13435 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13437 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13439 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13441 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13443 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13448 * pbkdf2 iterations
13451 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13454 * handle salt encoding
13457 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13459 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13461 const char p0
= saltbuf_pos
[i
+ 0];
13462 const char p1
= saltbuf_pos
[i
+ 1];
13464 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13465 | hex_convert (p0
) << 4;
13468 salt
->salt_len
= saltbuf_len
/ 2;
13471 * handle cipher encoding
13474 uint
*tmp
= (uint
*) mymalloc (32);
13476 char *cipherbuf_ptr
= (char *) tmp
;
13478 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13480 const char p0
= cipherbuf_pos
[i
+ 0];
13481 const char p1
= cipherbuf_pos
[i
+ 1];
13483 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13484 | hex_convert (p0
) << 4;
13487 // iv is stored at salt_buf 4 (length 16)
13488 // data is stored at salt_buf 8 (length 16)
13490 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13491 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13492 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13493 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13495 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13496 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13497 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13498 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13502 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13504 const char p0
= cipherbuf_pos
[j
+ 0];
13505 const char p1
= cipherbuf_pos
[j
+ 1];
13507 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13508 | hex_convert (p0
) << 4;
13515 digest
[0] = 0x10101010;
13516 digest
[1] = 0x10101010;
13517 digest
[2] = 0x10101010;
13518 digest
[3] = 0x10101010;
13520 return (PARSER_OK
);
13523 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13525 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13527 u32
*digest
= (u32
*) hash_buf
->digest
;
13529 salt_t
*salt
= hash_buf
->salt
;
13531 char *hashbuf_pos
= input_buf
;
13533 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13535 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13537 uint hash_len
= iterations_pos
- hashbuf_pos
;
13539 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13543 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13545 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13547 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13551 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13553 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13555 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13557 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13559 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13561 salt
->salt_len
= salt_len
;
13563 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13565 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13566 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13567 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13568 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13570 return (PARSER_OK
);
13573 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13575 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13577 u32
*digest
= (u32
*) hash_buf
->digest
;
13579 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13580 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13581 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13582 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13583 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13584 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13585 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13586 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13588 digest
[0] = byte_swap_32 (digest
[0]);
13589 digest
[1] = byte_swap_32 (digest
[1]);
13590 digest
[2] = byte_swap_32 (digest
[2]);
13591 digest
[3] = byte_swap_32 (digest
[3]);
13592 digest
[4] = byte_swap_32 (digest
[4]);
13593 digest
[5] = byte_swap_32 (digest
[5]);
13594 digest
[6] = byte_swap_32 (digest
[6]);
13595 digest
[7] = byte_swap_32 (digest
[7]);
13597 return (PARSER_OK
);
13600 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13602 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13604 u32
*digest
= (u32
*) hash_buf
->digest
;
13606 salt_t
*salt
= hash_buf
->salt
;
13608 char *salt_pos
= input_buf
+ 3;
13610 uint iterations_len
= 0;
13612 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13616 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13618 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13619 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13623 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13627 iterations_len
+= 8;
13631 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13634 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13636 char *hash_pos
= strchr (salt_pos
, '$');
13638 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13640 uint salt_len
= hash_pos
- salt_pos
;
13642 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13644 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13646 salt
->salt_len
= salt_len
;
13650 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13652 return (PARSER_OK
);
13655 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13657 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13659 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13661 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13663 u64
*digest
= (u64
*) hash_buf
->digest
;
13665 salt_t
*salt
= hash_buf
->salt
;
13667 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13669 char *iter_pos
= input_buf
+ 4;
13671 char *salt_pos
= strchr (iter_pos
, '$');
13673 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13677 char *hash_pos
= strchr (salt_pos
, '$');
13679 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13681 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13685 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13686 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13687 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13688 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13689 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13690 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13691 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13692 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13694 uint salt_len
= hash_pos
- salt_pos
- 1;
13696 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13698 salt
->salt_len
= salt_len
/ 2;
13700 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13701 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13702 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13703 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13704 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13705 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13706 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13707 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13709 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13710 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13711 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13712 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13713 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13714 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13715 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13716 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13717 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13718 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13720 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13722 salt
->salt_iter
= atoi (iter_pos
) - 1;
13724 return (PARSER_OK
);
13727 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13729 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13731 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13733 u32
*digest
= (u32
*) hash_buf
->digest
;
13735 salt_t
*salt
= hash_buf
->salt
;
13737 char *salt_pos
= input_buf
+ 14;
13739 char *hash_pos
= strchr (salt_pos
, '*');
13741 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13745 uint salt_len
= hash_pos
- salt_pos
- 1;
13747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13749 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13753 salt
->salt_len
= salt_len
;
13755 u8 tmp_buf
[100] = { 0 };
13757 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13759 memcpy (digest
, tmp_buf
, 32);
13761 digest
[0] = byte_swap_32 (digest
[0]);
13762 digest
[1] = byte_swap_32 (digest
[1]);
13763 digest
[2] = byte_swap_32 (digest
[2]);
13764 digest
[3] = byte_swap_32 (digest
[3]);
13765 digest
[4] = byte_swap_32 (digest
[4]);
13766 digest
[5] = byte_swap_32 (digest
[5]);
13767 digest
[6] = byte_swap_32 (digest
[6]);
13768 digest
[7] = byte_swap_32 (digest
[7]);
13770 digest
[0] -= SHA256M_A
;
13771 digest
[1] -= SHA256M_B
;
13772 digest
[2] -= SHA256M_C
;
13773 digest
[3] -= SHA256M_D
;
13774 digest
[4] -= SHA256M_E
;
13775 digest
[5] -= SHA256M_F
;
13776 digest
[6] -= SHA256M_G
;
13777 digest
[7] -= SHA256M_H
;
13779 return (PARSER_OK
);
13782 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13784 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13786 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13788 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13790 u64
*digest
= (u64
*) hash_buf
->digest
;
13792 salt_t
*salt
= hash_buf
->salt
;
13794 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13796 char *iter_pos
= input_buf
+ 19;
13798 char *salt_pos
= strchr (iter_pos
, '.');
13800 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13804 char *hash_pos
= strchr (salt_pos
, '.');
13806 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13808 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13812 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13813 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13814 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13815 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13816 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13817 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13818 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13819 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13821 uint salt_len
= hash_pos
- salt_pos
- 1;
13825 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13829 for (i
= 0; i
< salt_len
; i
++)
13831 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13834 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13835 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13837 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13839 salt
->salt_len
= salt_len
;
13841 salt
->salt_iter
= atoi (iter_pos
) - 1;
13843 return (PARSER_OK
);
13846 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13848 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13850 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13852 u64
*digest
= (u64
*) hash_buf
->digest
;
13854 salt_t
*salt
= hash_buf
->salt
;
13856 u8 tmp_buf
[120] = { 0 };
13858 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13860 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13862 memcpy (digest
, tmp_buf
, 64);
13864 digest
[0] = byte_swap_64 (digest
[0]);
13865 digest
[1] = byte_swap_64 (digest
[1]);
13866 digest
[2] = byte_swap_64 (digest
[2]);
13867 digest
[3] = byte_swap_64 (digest
[3]);
13868 digest
[4] = byte_swap_64 (digest
[4]);
13869 digest
[5] = byte_swap_64 (digest
[5]);
13870 digest
[6] = byte_swap_64 (digest
[6]);
13871 digest
[7] = byte_swap_64 (digest
[7]);
13873 digest
[0] -= SHA512M_A
;
13874 digest
[1] -= SHA512M_B
;
13875 digest
[2] -= SHA512M_C
;
13876 digest
[3] -= SHA512M_D
;
13877 digest
[4] -= SHA512M_E
;
13878 digest
[5] -= SHA512M_F
;
13879 digest
[6] -= SHA512M_G
;
13880 digest
[7] -= SHA512M_H
;
13882 int salt_len
= tmp_len
- 64;
13884 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13886 salt
->salt_len
= salt_len
;
13888 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13890 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13892 char *ptr
= (char *) salt
->salt_buf
;
13894 ptr
[salt
->salt_len
] = 0x80;
13897 return (PARSER_OK
);
13900 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13902 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13904 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13908 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13911 u32
*digest
= (u32
*) hash_buf
->digest
;
13913 salt_t
*salt
= hash_buf
->salt
;
13915 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13916 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13917 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13918 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13920 digest
[0] = byte_swap_32 (digest
[0]);
13921 digest
[1] = byte_swap_32 (digest
[1]);
13922 digest
[2] = byte_swap_32 (digest
[2]);
13923 digest
[3] = byte_swap_32 (digest
[3]);
13925 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13927 uint salt_len
= input_len
- 32 - 1;
13929 char *salt_buf
= input_buf
+ 32 + 1;
13931 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13933 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13935 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13937 salt
->salt_len
= salt_len
;
13939 return (PARSER_OK
);
13942 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13944 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13946 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13950 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13953 u32
*digest
= (u32
*) hash_buf
->digest
;
13955 salt_t
*salt
= hash_buf
->salt
;
13957 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13958 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13959 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13960 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13961 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13963 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13965 uint salt_len
= input_len
- 40 - 1;
13967 char *salt_buf
= input_buf
+ 40 + 1;
13969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13971 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13973 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13975 salt
->salt_len
= salt_len
;
13977 return (PARSER_OK
);
13980 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13982 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13984 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13988 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13991 u32
*digest
= (u32
*) hash_buf
->digest
;
13993 salt_t
*salt
= hash_buf
->salt
;
13995 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13996 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13997 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13998 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13999 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14000 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14001 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14002 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14004 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14006 uint salt_len
= input_len
- 64 - 1;
14008 char *salt_buf
= input_buf
+ 64 + 1;
14010 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14012 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14016 salt
->salt_len
= salt_len
;
14018 return (PARSER_OK
);
14021 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14023 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14025 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14029 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14032 u64
*digest
= (u64
*) hash_buf
->digest
;
14034 salt_t
*salt
= hash_buf
->salt
;
14036 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14037 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14038 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14039 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14040 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14041 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14042 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14043 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14045 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14047 uint salt_len
= input_len
- 128 - 1;
14049 char *salt_buf
= input_buf
+ 128 + 1;
14051 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14053 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14055 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14057 salt
->salt_len
= salt_len
;
14059 return (PARSER_OK
);
14062 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14064 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14066 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14068 u32
*digest
= (u32
*) hash_buf
->digest
;
14070 salt_t
*salt
= hash_buf
->salt
;
14072 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14078 char *user_pos
= input_buf
+ 10 + 1;
14080 char *realm_pos
= strchr (user_pos
, '$');
14082 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14084 uint user_len
= realm_pos
- user_pos
;
14086 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14090 char *salt_pos
= strchr (realm_pos
, '$');
14092 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14094 uint realm_len
= salt_pos
- realm_pos
;
14096 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14100 char *data_pos
= strchr (salt_pos
, '$');
14102 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14104 uint salt_len
= data_pos
- salt_pos
;
14106 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14110 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14112 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14118 memcpy (krb5pa
->user
, user_pos
, user_len
);
14119 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14120 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14122 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14124 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14126 const char p0
= data_pos
[i
+ 0];
14127 const char p1
= data_pos
[i
+ 1];
14129 *timestamp_ptr
++ = hex_convert (p1
) << 0
14130 | hex_convert (p0
) << 4;
14133 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14135 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14137 const char p0
= data_pos
[i
+ 0];
14138 const char p1
= data_pos
[i
+ 1];
14140 *checksum_ptr
++ = hex_convert (p1
) << 0
14141 | hex_convert (p0
) << 4;
14145 * copy some data to generic buffers to make sorting happy
14148 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14149 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14150 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14151 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14152 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14153 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14154 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14155 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14156 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14158 salt
->salt_len
= 36;
14160 digest
[0] = krb5pa
->checksum
[0];
14161 digest
[1] = krb5pa
->checksum
[1];
14162 digest
[2] = krb5pa
->checksum
[2];
14163 digest
[3] = krb5pa
->checksum
[3];
14165 return (PARSER_OK
);
14168 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14170 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14172 u32
*digest
= (u32
*) hash_buf
->digest
;
14174 salt_t
*salt
= hash_buf
->salt
;
14180 char *salt_pos
= input_buf
;
14182 char *hash_pos
= strchr (salt_pos
, '$');
14184 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14186 uint salt_len
= hash_pos
- salt_pos
;
14188 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14192 uint hash_len
= input_len
- 1 - salt_len
;
14194 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14202 for (uint i
= 0; i
< salt_len
; i
++)
14204 if (salt_pos
[i
] == ' ') continue;
14209 // SAP user names cannot be longer than 12 characters
14210 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14212 // SAP user name cannot start with ! or ?
14213 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14219 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14221 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14223 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14225 salt
->salt_len
= salt_len
;
14227 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14228 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14232 digest
[0] = byte_swap_32 (digest
[0]);
14233 digest
[1] = byte_swap_32 (digest
[1]);
14235 return (PARSER_OK
);
14238 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14240 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14242 u32
*digest
= (u32
*) hash_buf
->digest
;
14244 salt_t
*salt
= hash_buf
->salt
;
14250 char *salt_pos
= input_buf
;
14252 char *hash_pos
= strchr (salt_pos
, '$');
14254 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14256 uint salt_len
= hash_pos
- salt_pos
;
14258 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14262 uint hash_len
= input_len
- 1 - salt_len
;
14264 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14272 for (uint i
= 0; i
< salt_len
; i
++)
14274 if (salt_pos
[i
] == ' ') continue;
14279 // SAP user names cannot be longer than 12 characters
14280 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14281 // so far nobody complained so we stay with this because it helps in optimization
14282 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14284 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14286 // SAP user name cannot start with ! or ?
14287 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14293 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14295 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14297 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14299 salt
->salt_len
= salt_len
;
14301 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14302 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14303 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14304 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14305 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14307 return (PARSER_OK
);
14310 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14312 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14314 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14316 u64
*digest
= (u64
*) hash_buf
->digest
;
14318 salt_t
*salt
= hash_buf
->salt
;
14320 char *iter_pos
= input_buf
+ 3;
14322 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14324 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14326 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14328 salt
->salt_iter
= salt_iter
;
14330 char *salt_pos
= iter_pos
+ 1;
14334 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14336 salt
->salt_len
= salt_len
;
14338 char *hash_pos
= salt_pos
+ salt_len
;
14340 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14344 char *tmp
= (char *) salt
->salt_buf_pc
;
14346 tmp
[0] = hash_pos
[42];
14350 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14351 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14352 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14353 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14359 return (PARSER_OK
);
14362 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14364 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14366 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14368 u32
*digest
= (u32
*) hash_buf
->digest
;
14370 salt_t
*salt
= hash_buf
->salt
;
14372 char *salt_buf
= input_buf
+ 6;
14374 uint salt_len
= 16;
14376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14382 salt
->salt_len
= salt_len
;
14384 char *hash_pos
= input_buf
+ 6 + 16;
14386 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14387 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14388 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14389 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14390 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14391 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14392 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14393 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14395 return (PARSER_OK
);
14398 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14400 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14402 u32
*digest
= (u32
*) hash_buf
->digest
;
14404 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14405 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14409 return (PARSER_OK
);
14412 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14414 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14416 u32
*digest
= (u32
*) hash_buf
->digest
;
14418 salt_t
*salt
= hash_buf
->salt
;
14420 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14422 char *saltbuf_pos
= input_buf
;
14424 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14426 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14428 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14430 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14431 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14433 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14437 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14439 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14441 char *salt_ptr
= (char *) saltbuf_pos
;
14442 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14447 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14449 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14452 rakp_ptr
[j
] = 0x80;
14454 rakp
->salt_len
= j
;
14456 for (i
= 0; i
< 64; i
++)
14458 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14461 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14462 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14463 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14464 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14465 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14466 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14467 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14468 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14470 salt
->salt_len
= 32; // muss min. 32 haben
14472 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14473 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14474 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14475 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14476 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14478 return (PARSER_OK
);
14481 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14483 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14485 u32
*digest
= (u32
*) hash_buf
->digest
;
14487 salt_t
*salt
= hash_buf
->salt
;
14489 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14491 char *salt_pos
= input_buf
+ 1;
14493 memcpy (salt
->salt_buf
, salt_pos
, 8);
14495 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14496 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14498 salt
->salt_len
= 8;
14500 char *hash_pos
= salt_pos
+ 8;
14502 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14503 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14504 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14505 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14506 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14508 digest
[0] -= SHA1M_A
;
14509 digest
[1] -= SHA1M_B
;
14510 digest
[2] -= SHA1M_C
;
14511 digest
[3] -= SHA1M_D
;
14512 digest
[4] -= SHA1M_E
;
14514 return (PARSER_OK
);
14517 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14519 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14521 u32
*digest
= (u32
*) hash_buf
->digest
;
14523 salt_t
*salt
= hash_buf
->salt
;
14525 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14526 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14527 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14528 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14530 digest
[0] = byte_swap_32 (digest
[0]);
14531 digest
[1] = byte_swap_32 (digest
[1]);
14532 digest
[2] = byte_swap_32 (digest
[2]);
14533 digest
[3] = byte_swap_32 (digest
[3]);
14535 digest
[0] -= MD5M_A
;
14536 digest
[1] -= MD5M_B
;
14537 digest
[2] -= MD5M_C
;
14538 digest
[3] -= MD5M_D
;
14540 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14542 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14544 u32
*salt_buf
= salt
->salt_buf
;
14546 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14547 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14548 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14549 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14551 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14552 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14553 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14554 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14556 salt
->salt_len
= 16 + 1;
14558 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14560 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14562 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14564 return (PARSER_OK
);
14567 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14569 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14571 u32
*digest
= (u32
*) hash_buf
->digest
;
14573 salt_t
*salt
= hash_buf
->salt
;
14575 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14581 char *hashbuf_pos
= input_buf
;
14583 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14585 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14587 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14589 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14593 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14595 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14597 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14599 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14603 char *databuf_pos
= strchr (iteration_pos
, ':');
14605 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14607 const uint iteration_len
= databuf_pos
- iteration_pos
;
14609 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14610 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14612 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14614 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14615 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14621 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14622 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14623 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14624 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14625 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14626 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14627 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14628 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14632 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14634 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14636 const char p0
= saltbuf_pos
[i
+ 0];
14637 const char p1
= saltbuf_pos
[i
+ 1];
14639 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14640 | hex_convert (p0
) << 4;
14643 salt
->salt_buf
[4] = 0x01000000;
14644 salt
->salt_buf
[5] = 0x80;
14646 salt
->salt_len
= saltbuf_len
/ 2;
14650 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14654 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14656 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14658 const char p0
= databuf_pos
[i
+ 0];
14659 const char p1
= databuf_pos
[i
+ 1];
14661 *databuf_ptr
++ = hex_convert (p1
) << 0
14662 | hex_convert (p0
) << 4;
14665 *databuf_ptr
++ = 0x80;
14667 for (uint i
= 0; i
< 512; i
++)
14669 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14672 cloudkey
->data_len
= databuf_len
/ 2;
14674 return (PARSER_OK
);
14677 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14679 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14681 u32
*digest
= (u32
*) hash_buf
->digest
;
14683 salt_t
*salt
= hash_buf
->salt
;
14689 char *hashbuf_pos
= input_buf
;
14691 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14693 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14695 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14697 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14701 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14703 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14705 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14707 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14709 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14713 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14715 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14717 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14719 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14721 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14725 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14727 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14728 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14730 // ok, the plan for this algorithm is the following:
14731 // we have 2 salts here, the domain-name and a random salt
14732 // while both are used in the initial transformation,
14733 // only the random salt is used in the following iterations
14734 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14735 // and one that includes only the real salt (stored into salt_buf[]).
14736 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14738 u8 tmp_buf
[100] = { 0 };
14740 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14742 memcpy (digest
, tmp_buf
, 20);
14744 digest
[0] = byte_swap_32 (digest
[0]);
14745 digest
[1] = byte_swap_32 (digest
[1]);
14746 digest
[2] = byte_swap_32 (digest
[2]);
14747 digest
[3] = byte_swap_32 (digest
[3]);
14748 digest
[4] = byte_swap_32 (digest
[4]);
14752 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14754 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14756 char *len_ptr
= NULL
;
14758 for (uint i
= 0; i
< domainbuf_len
; i
++)
14760 if (salt_buf_pc_ptr
[i
] == '.')
14762 len_ptr
= &salt_buf_pc_ptr
[i
];
14772 salt
->salt_buf_pc
[7] = domainbuf_len
;
14776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14778 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14782 salt
->salt_len
= salt_len
;
14786 salt
->salt_iter
= atoi (iteration_pos
);
14788 return (PARSER_OK
);
14791 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14793 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14795 u32
*digest
= (u32
*) hash_buf
->digest
;
14797 salt_t
*salt
= hash_buf
->salt
;
14799 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14800 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14801 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14802 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14803 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14805 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14807 uint salt_len
= input_len
- 40 - 1;
14809 char *salt_buf
= input_buf
+ 40 + 1;
14811 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14813 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14815 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14817 salt
->salt_len
= salt_len
;
14819 return (PARSER_OK
);
14822 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14824 const u8 ascii_to_ebcdic
[] =
14826 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14827 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14828 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14829 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14830 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14831 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14832 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14833 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14834 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14835 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14836 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14837 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14838 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14839 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14840 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14841 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14844 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14846 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14848 u32
*digest
= (u32
*) hash_buf
->digest
;
14850 salt_t
*salt
= hash_buf
->salt
;
14852 char *salt_pos
= input_buf
+ 6 + 1;
14854 char *digest_pos
= strchr (salt_pos
, '*');
14856 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14858 uint salt_len
= digest_pos
- salt_pos
;
14860 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14862 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14864 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14868 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14869 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14875 salt
->salt_len
= salt_len
;
14877 for (uint i
= 0; i
< salt_len
; i
++)
14879 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14881 for (uint i
= salt_len
; i
< 8; i
++)
14883 salt_buf_pc_ptr
[i
] = 0x40;
14888 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14890 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14891 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14893 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14894 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14896 digest
[0] = byte_swap_32 (digest
[0]);
14897 digest
[1] = byte_swap_32 (digest
[1]);
14899 IP (digest
[0], digest
[1], tt
);
14901 digest
[0] = rotr32 (digest
[0], 29);
14902 digest
[1] = rotr32 (digest
[1], 29);
14906 return (PARSER_OK
);
14909 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14911 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14913 u32
*digest
= (u32
*) hash_buf
->digest
;
14915 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14916 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14917 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14918 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14920 digest
[0] = byte_swap_32 (digest
[0]);
14921 digest
[1] = byte_swap_32 (digest
[1]);
14922 digest
[2] = byte_swap_32 (digest
[2]);
14923 digest
[3] = byte_swap_32 (digest
[3]);
14925 return (PARSER_OK
);
14928 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14930 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14932 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14934 u32
*digest
= (u32
*) hash_buf
->digest
;
14936 salt_t
*salt
= hash_buf
->salt
;
14938 u8 tmp_buf
[120] = { 0 };
14940 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14942 tmp_buf
[3] += -4; // dont ask!
14944 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14946 salt
->salt_len
= 5;
14948 memcpy (digest
, tmp_buf
+ 5, 9);
14950 // yes, only 9 byte are needed to crack, but 10 to display
14952 salt
->salt_buf_pc
[7] = input_buf
[20];
14954 return (PARSER_OK
);
14957 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14959 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14961 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14963 u32
*digest
= (u32
*) hash_buf
->digest
;
14965 salt_t
*salt
= hash_buf
->salt
;
14967 u8 tmp_buf
[120] = { 0 };
14969 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14971 tmp_buf
[3] += -4; // dont ask!
14975 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14977 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)
14981 char tmp_iter_buf
[11] = { 0 };
14983 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14985 tmp_iter_buf
[10] = 0;
14987 salt
->salt_iter
= atoi (tmp_iter_buf
);
14989 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14991 return (PARSER_SALT_ITERATION
);
14994 salt
->salt_iter
--; // first round in init
14996 // 2 additional bytes for display only
14998 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14999 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15003 memcpy (digest
, tmp_buf
+ 28, 8);
15005 digest
[0] = byte_swap_32 (digest
[0]);
15006 digest
[1] = byte_swap_32 (digest
[1]);
15010 return (PARSER_OK
);
15013 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15015 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15017 u32
*digest
= (u32
*) hash_buf
->digest
;
15019 salt_t
*salt
= hash_buf
->salt
;
15021 char *salt_buf_pos
= input_buf
;
15023 char *hash_buf_pos
= salt_buf_pos
+ 6;
15025 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15026 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15027 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15028 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15029 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15030 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15031 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15032 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15034 digest
[0] -= SHA256M_A
;
15035 digest
[1] -= SHA256M_B
;
15036 digest
[2] -= SHA256M_C
;
15037 digest
[3] -= SHA256M_D
;
15038 digest
[4] -= SHA256M_E
;
15039 digest
[5] -= SHA256M_F
;
15040 digest
[6] -= SHA256M_G
;
15041 digest
[7] -= SHA256M_H
;
15043 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15045 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15047 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15049 salt
->salt_len
= salt_len
;
15051 return (PARSER_OK
);
15054 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15056 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15058 u32
*digest
= (u32
*) hash_buf
->digest
;
15060 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15062 salt_t
*salt
= hash_buf
->salt
;
15064 char *salt_buf
= input_buf
+ 6;
15066 char *digest_buf
= strchr (salt_buf
, '$');
15068 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15070 uint salt_len
= digest_buf
- salt_buf
;
15072 digest_buf
++; // skip the '$' symbol
15074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15076 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15080 salt
->salt_len
= salt_len
;
15082 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15083 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15084 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15085 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15087 digest
[0] = byte_swap_32 (digest
[0]);
15088 digest
[1] = byte_swap_32 (digest
[1]);
15089 digest
[2] = byte_swap_32 (digest
[2]);
15090 digest
[3] = byte_swap_32 (digest
[3]);
15092 digest
[0] -= MD5M_A
;
15093 digest
[1] -= MD5M_B
;
15094 digest
[2] -= MD5M_C
;
15095 digest
[3] -= MD5M_D
;
15097 return (PARSER_OK
);
15100 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15102 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15104 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15106 u32
*digest
= (u32
*) hash_buf
->digest
;
15108 salt_t
*salt
= hash_buf
->salt
;
15110 char *salt_buf
= input_buf
+ 3;
15112 char *digest_buf
= strchr (salt_buf
, '$');
15114 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15116 uint salt_len
= digest_buf
- salt_buf
;
15118 digest_buf
++; // skip the '$' symbol
15120 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15122 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15124 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15126 salt_buf_ptr
[salt_len
] = 0x2d;
15128 salt
->salt_len
= salt_len
+ 1;
15130 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15131 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15132 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15133 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15135 digest
[0] = byte_swap_32 (digest
[0]);
15136 digest
[1] = byte_swap_32 (digest
[1]);
15137 digest
[2] = byte_swap_32 (digest
[2]);
15138 digest
[3] = byte_swap_32 (digest
[3]);
15140 digest
[0] -= MD5M_A
;
15141 digest
[1] -= MD5M_B
;
15142 digest
[2] -= MD5M_C
;
15143 digest
[3] -= MD5M_D
;
15145 return (PARSER_OK
);
15148 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15150 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15152 u32
*digest
= (u32
*) hash_buf
->digest
;
15154 salt_t
*salt
= hash_buf
->salt
;
15156 u8 tmp_buf
[100] = { 0 };
15158 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15160 memcpy (digest
, tmp_buf
, 20);
15162 digest
[0] = byte_swap_32 (digest
[0]);
15163 digest
[1] = byte_swap_32 (digest
[1]);
15164 digest
[2] = byte_swap_32 (digest
[2]);
15165 digest
[3] = byte_swap_32 (digest
[3]);
15166 digest
[4] = byte_swap_32 (digest
[4]);
15168 digest
[0] -= SHA1M_A
;
15169 digest
[1] -= SHA1M_B
;
15170 digest
[2] -= SHA1M_C
;
15171 digest
[3] -= SHA1M_D
;
15172 digest
[4] -= SHA1M_E
;
15174 salt
->salt_buf
[0] = 0x80;
15176 salt
->salt_len
= 0;
15178 return (PARSER_OK
);
15181 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15183 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15185 u32
*digest
= (u32
*) hash_buf
->digest
;
15187 salt_t
*salt
= hash_buf
->salt
;
15189 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15190 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15191 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15192 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15194 digest
[0] = byte_swap_32 (digest
[0]);
15195 digest
[1] = byte_swap_32 (digest
[1]);
15196 digest
[2] = byte_swap_32 (digest
[2]);
15197 digest
[3] = byte_swap_32 (digest
[3]);
15199 digest
[0] -= MD5M_A
;
15200 digest
[1] -= MD5M_B
;
15201 digest
[2] -= MD5M_C
;
15202 digest
[3] -= MD5M_D
;
15204 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15206 uint salt_len
= input_len
- 32 - 1;
15208 char *salt_buf
= input_buf
+ 32 + 1;
15210 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15212 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15214 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15217 * add static "salt" part
15220 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15224 salt
->salt_len
= salt_len
;
15226 return (PARSER_OK
);
15229 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15231 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15233 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15235 u32
*digest
= (u32
*) hash_buf
->digest
;
15237 salt_t
*salt
= hash_buf
->salt
;
15239 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15245 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15247 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15249 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15251 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15253 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15257 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15259 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15261 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15263 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15267 char *keybuf_pos
= strchr (keylen_pos
, '$');
15269 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15271 uint keylen_len
= keybuf_pos
- keylen_pos
;
15273 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15277 char *databuf_pos
= strchr (keybuf_pos
, '$');
15279 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15281 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15283 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15287 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15289 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15295 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15296 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15297 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15298 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15300 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15301 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15302 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15303 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15305 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15306 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15307 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15308 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15310 salt
->salt_len
= 16;
15311 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15313 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15315 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15318 return (PARSER_OK
);
15321 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15323 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15325 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15327 u32
*digest
= (u32
*) hash_buf
->digest
;
15329 salt_t
*salt
= hash_buf
->salt
;
15335 // first is the N salt parameter
15337 char *N_pos
= input_buf
+ 6;
15339 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15343 salt
->scrypt_N
= atoi (N_pos
);
15347 char *r_pos
= strchr (N_pos
, ':');
15349 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15353 salt
->scrypt_r
= atoi (r_pos
);
15357 char *p_pos
= strchr (r_pos
, ':');
15359 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15363 salt
->scrypt_p
= atoi (p_pos
);
15367 char *saltbuf_pos
= strchr (p_pos
, ':');
15369 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15373 char *hash_pos
= strchr (saltbuf_pos
, ':');
15375 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15381 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15383 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15385 u8 tmp_buf
[33] = { 0 };
15387 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15389 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15391 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15393 salt
->salt_len
= tmp_len
;
15394 salt
->salt_iter
= 1;
15396 // digest - base64 decode
15398 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15400 tmp_len
= input_len
- (hash_pos
- input_buf
);
15402 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15404 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15406 memcpy (digest
, tmp_buf
, 32);
15408 return (PARSER_OK
);
15411 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15413 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15415 u32
*digest
= (u32
*) hash_buf
->digest
;
15417 salt_t
*salt
= hash_buf
->salt
;
15423 char decrypted
[76] = { 0 }; // iv + hash
15425 juniper_decrypt_hash (input_buf
, decrypted
);
15427 char *md5crypt_hash
= decrypted
+ 12;
15429 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15431 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15433 char *salt_pos
= md5crypt_hash
+ 3;
15435 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15437 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15439 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15443 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15445 return (PARSER_OK
);
15448 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15450 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15452 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15454 u32
*digest
= (u32
*) hash_buf
->digest
;
15456 salt_t
*salt
= hash_buf
->salt
;
15458 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15464 // first is *raw* salt
15466 char *salt_pos
= input_buf
+ 3;
15468 char *hash_pos
= strchr (salt_pos
, '$');
15470 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15472 uint salt_len
= hash_pos
- salt_pos
;
15474 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15478 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15480 memcpy (salt_buf_ptr
, salt_pos
, 14);
15482 salt_buf_ptr
[17] = 0x01;
15483 salt_buf_ptr
[18] = 0x80;
15485 // add some stuff to normal salt to make sorted happy
15487 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15488 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15489 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15490 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15492 salt
->salt_len
= salt_len
;
15493 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15495 // base64 decode hash
15497 u8 tmp_buf
[100] = { 0 };
15499 uint hash_len
= input_len
- 3 - salt_len
- 1;
15501 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15503 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15505 memcpy (digest
, tmp_buf
, 32);
15507 digest
[0] = byte_swap_32 (digest
[0]);
15508 digest
[1] = byte_swap_32 (digest
[1]);
15509 digest
[2] = byte_swap_32 (digest
[2]);
15510 digest
[3] = byte_swap_32 (digest
[3]);
15511 digest
[4] = byte_swap_32 (digest
[4]);
15512 digest
[5] = byte_swap_32 (digest
[5]);
15513 digest
[6] = byte_swap_32 (digest
[6]);
15514 digest
[7] = byte_swap_32 (digest
[7]);
15516 return (PARSER_OK
);
15519 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15521 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15523 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15525 u32
*digest
= (u32
*) hash_buf
->digest
;
15527 salt_t
*salt
= hash_buf
->salt
;
15533 // first is *raw* salt
15535 char *salt_pos
= input_buf
+ 3;
15537 char *hash_pos
= strchr (salt_pos
, '$');
15539 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15541 uint salt_len
= hash_pos
- salt_pos
;
15543 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15545 salt
->salt_len
= salt_len
;
15548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15550 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15551 salt_buf_ptr
[salt_len
] = 0;
15553 // base64 decode hash
15555 u8 tmp_buf
[100] = { 0 };
15557 uint hash_len
= input_len
- 3 - salt_len
- 1;
15559 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15561 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15563 memcpy (digest
, tmp_buf
, 32);
15566 salt
->scrypt_N
= 16384;
15567 salt
->scrypt_r
= 1;
15568 salt
->scrypt_p
= 1;
15569 salt
->salt_iter
= 1;
15571 return (PARSER_OK
);
15574 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15576 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15578 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15580 u32
*digest
= (u32
*) hash_buf
->digest
;
15582 salt_t
*salt
= hash_buf
->salt
;
15584 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15590 char *version_pos
= input_buf
+ 8 + 1;
15592 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15594 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15596 u32 version_len
= verifierHashSize_pos
- version_pos
;
15598 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15600 verifierHashSize_pos
++;
15602 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15604 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15606 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15608 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15612 char *saltSize_pos
= strchr (keySize_pos
, '*');
15614 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15616 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15618 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15622 char *osalt_pos
= strchr (saltSize_pos
, '*');
15624 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15626 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15628 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15632 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15634 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15636 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15638 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15640 encryptedVerifier_pos
++;
15642 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15644 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15646 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15648 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15650 encryptedVerifierHash_pos
++;
15652 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;
15654 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15656 const uint version
= atoi (version_pos
);
15658 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15660 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15662 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15664 const uint keySize
= atoi (keySize_pos
);
15666 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15668 office2007
->keySize
= keySize
;
15670 const uint saltSize
= atoi (saltSize_pos
);
15672 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15678 salt
->salt_len
= 16;
15679 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15681 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15682 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15683 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15684 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15690 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15691 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15692 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15693 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15695 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15696 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15697 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15698 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15699 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15705 digest
[0] = office2007
->encryptedVerifierHash
[0];
15706 digest
[1] = office2007
->encryptedVerifierHash
[1];
15707 digest
[2] = office2007
->encryptedVerifierHash
[2];
15708 digest
[3] = office2007
->encryptedVerifierHash
[3];
15710 return (PARSER_OK
);
15713 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15715 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15717 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15719 u32
*digest
= (u32
*) hash_buf
->digest
;
15721 salt_t
*salt
= hash_buf
->salt
;
15723 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15729 char *version_pos
= input_buf
+ 8 + 1;
15731 char *spinCount_pos
= strchr (version_pos
, '*');
15733 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15735 u32 version_len
= spinCount_pos
- version_pos
;
15737 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15741 char *keySize_pos
= strchr (spinCount_pos
, '*');
15743 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15745 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15747 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15751 char *saltSize_pos
= strchr (keySize_pos
, '*');
15753 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15755 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15757 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15761 char *osalt_pos
= strchr (saltSize_pos
, '*');
15763 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15765 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15767 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15771 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15773 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15775 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15777 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15779 encryptedVerifier_pos
++;
15781 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15783 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15785 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15787 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15789 encryptedVerifierHash_pos
++;
15791 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;
15793 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15795 const uint version
= atoi (version_pos
);
15797 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15799 const uint spinCount
= atoi (spinCount_pos
);
15801 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15803 const uint keySize
= atoi (keySize_pos
);
15805 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15807 const uint saltSize
= atoi (saltSize_pos
);
15809 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15815 salt
->salt_len
= 16;
15816 salt
->salt_iter
= spinCount
;
15818 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15819 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15820 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15821 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15827 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15828 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15829 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15830 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15832 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15833 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15834 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15835 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15836 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15837 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15838 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15839 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15845 digest
[0] = office2010
->encryptedVerifierHash
[0];
15846 digest
[1] = office2010
->encryptedVerifierHash
[1];
15847 digest
[2] = office2010
->encryptedVerifierHash
[2];
15848 digest
[3] = office2010
->encryptedVerifierHash
[3];
15850 return (PARSER_OK
);
15853 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15855 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15857 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15859 u32
*digest
= (u32
*) hash_buf
->digest
;
15861 salt_t
*salt
= hash_buf
->salt
;
15863 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15869 char *version_pos
= input_buf
+ 8 + 1;
15871 char *spinCount_pos
= strchr (version_pos
, '*');
15873 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15875 u32 version_len
= spinCount_pos
- version_pos
;
15877 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15881 char *keySize_pos
= strchr (spinCount_pos
, '*');
15883 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15885 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15887 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15891 char *saltSize_pos
= strchr (keySize_pos
, '*');
15893 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15895 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15897 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15901 char *osalt_pos
= strchr (saltSize_pos
, '*');
15903 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15905 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15907 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15911 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15913 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15915 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15917 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15919 encryptedVerifier_pos
++;
15921 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15923 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15925 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15927 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15929 encryptedVerifierHash_pos
++;
15931 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;
15933 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15935 const uint version
= atoi (version_pos
);
15937 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15939 const uint spinCount
= atoi (spinCount_pos
);
15941 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15943 const uint keySize
= atoi (keySize_pos
);
15945 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15947 const uint saltSize
= atoi (saltSize_pos
);
15949 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15955 salt
->salt_len
= 16;
15956 salt
->salt_iter
= spinCount
;
15958 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15959 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15960 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15961 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15967 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15968 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15969 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15970 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15972 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15973 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15974 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15975 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15976 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15977 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15978 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15979 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15985 digest
[0] = office2013
->encryptedVerifierHash
[0];
15986 digest
[1] = office2013
->encryptedVerifierHash
[1];
15987 digest
[2] = office2013
->encryptedVerifierHash
[2];
15988 digest
[3] = office2013
->encryptedVerifierHash
[3];
15990 return (PARSER_OK
);
15993 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15995 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15997 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15999 u32
*digest
= (u32
*) hash_buf
->digest
;
16001 salt_t
*salt
= hash_buf
->salt
;
16003 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16009 char *version_pos
= input_buf
+ 11;
16011 char *osalt_pos
= strchr (version_pos
, '*');
16013 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 u32 version_len
= osalt_pos
- version_pos
;
16017 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16021 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16023 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16025 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16027 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16029 encryptedVerifier_pos
++;
16031 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16033 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16035 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16037 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16039 encryptedVerifierHash_pos
++;
16041 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16043 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16045 const uint version
= *version_pos
- 0x30;
16047 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16053 oldoffice01
->version
= version
;
16055 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16056 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16057 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16058 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16060 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16061 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16062 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16063 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16065 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16066 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16067 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16068 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16070 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16071 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16072 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16073 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16079 salt
->salt_len
= 16;
16081 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16082 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16083 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16084 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16086 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16087 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16088 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16089 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16091 // this is a workaround as office produces multiple documents with the same salt
16093 salt
->salt_len
+= 32;
16095 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16096 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16097 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16098 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16099 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16100 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16101 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16102 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16108 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16109 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16110 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16111 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16113 return (PARSER_OK
);
16116 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16118 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16121 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16123 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16125 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16127 u32
*digest
= (u32
*) hash_buf
->digest
;
16129 salt_t
*salt
= hash_buf
->salt
;
16131 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16137 char *version_pos
= input_buf
+ 11;
16139 char *osalt_pos
= strchr (version_pos
, '*');
16141 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16143 u32 version_len
= osalt_pos
- version_pos
;
16145 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16149 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16151 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16153 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16155 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16157 encryptedVerifier_pos
++;
16159 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16161 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16163 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16165 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16167 encryptedVerifierHash_pos
++;
16169 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16171 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16173 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16175 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16179 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16181 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16183 const uint version
= *version_pos
- 0x30;
16185 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16191 oldoffice01
->version
= version
;
16193 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16194 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16195 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16196 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16198 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16199 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16200 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16201 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16203 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16204 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16205 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16206 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16208 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16209 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16210 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16211 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16213 oldoffice01
->rc4key
[1] = 0;
16214 oldoffice01
->rc4key
[0] = 0;
16216 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16217 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16218 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16219 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16220 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16221 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16222 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16223 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16224 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16225 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16227 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16228 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16234 salt
->salt_len
= 16;
16236 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16237 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16238 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16239 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16241 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16242 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16243 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16244 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16246 // this is a workaround as office produces multiple documents with the same salt
16248 salt
->salt_len
+= 32;
16250 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16251 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16252 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16253 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16254 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16255 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16256 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16257 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16263 digest
[0] = oldoffice01
->rc4key
[0];
16264 digest
[1] = oldoffice01
->rc4key
[1];
16268 return (PARSER_OK
);
16271 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16273 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16275 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16277 u32
*digest
= (u32
*) hash_buf
->digest
;
16279 salt_t
*salt
= hash_buf
->salt
;
16281 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16287 char *version_pos
= input_buf
+ 11;
16289 char *osalt_pos
= strchr (version_pos
, '*');
16291 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16293 u32 version_len
= osalt_pos
- version_pos
;
16295 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16299 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16301 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16303 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16305 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16307 encryptedVerifier_pos
++;
16309 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16311 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16313 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16315 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16317 encryptedVerifierHash_pos
++;
16319 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16321 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16323 const uint version
= *version_pos
- 0x30;
16325 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16331 oldoffice34
->version
= version
;
16333 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16334 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16335 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16336 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16338 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16339 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16340 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16341 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16343 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16344 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16345 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16346 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16347 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16349 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16350 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16351 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16352 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16353 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16359 salt
->salt_len
= 16;
16361 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16362 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16363 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16364 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16366 // this is a workaround as office produces multiple documents with the same salt
16368 salt
->salt_len
+= 32;
16370 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16371 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16372 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16373 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16374 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16375 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16376 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16377 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16383 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16384 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16385 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16386 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16388 return (PARSER_OK
);
16391 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16393 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16395 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16398 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16400 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16402 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16404 u32
*digest
= (u32
*) hash_buf
->digest
;
16406 salt_t
*salt
= hash_buf
->salt
;
16408 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16414 char *version_pos
= input_buf
+ 11;
16416 char *osalt_pos
= strchr (version_pos
, '*');
16418 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16420 u32 version_len
= osalt_pos
- version_pos
;
16422 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16426 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16428 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16430 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16432 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16434 encryptedVerifier_pos
++;
16436 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16438 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16440 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16442 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16444 encryptedVerifierHash_pos
++;
16446 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16448 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16450 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16452 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16456 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16458 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16460 const uint version
= *version_pos
- 0x30;
16462 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16468 oldoffice34
->version
= version
;
16470 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16471 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16472 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16473 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16475 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16476 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16477 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16478 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16480 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16481 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16482 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16483 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16484 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16486 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16487 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16488 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16489 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16490 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16492 oldoffice34
->rc4key
[1] = 0;
16493 oldoffice34
->rc4key
[0] = 0;
16495 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16496 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16497 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16498 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16499 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16500 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16501 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16502 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16503 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16504 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16506 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16507 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16513 salt
->salt_len
= 16;
16515 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16516 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16517 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16518 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16520 // this is a workaround as office produces multiple documents with the same salt
16522 salt
->salt_len
+= 32;
16524 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16525 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16526 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16527 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16528 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16529 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16530 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16531 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16537 digest
[0] = oldoffice34
->rc4key
[0];
16538 digest
[1] = oldoffice34
->rc4key
[1];
16542 return (PARSER_OK
);
16545 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16547 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16549 u32
*digest
= (u32
*) hash_buf
->digest
;
16551 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16552 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16553 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16554 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16556 digest
[0] = byte_swap_32 (digest
[0]);
16557 digest
[1] = byte_swap_32 (digest
[1]);
16558 digest
[2] = byte_swap_32 (digest
[2]);
16559 digest
[3] = byte_swap_32 (digest
[3]);
16561 return (PARSER_OK
);
16564 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16566 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16568 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16570 u32
*digest
= (u32
*) hash_buf
->digest
;
16572 salt_t
*salt
= hash_buf
->salt
;
16574 char *signature_pos
= input_buf
;
16576 char *salt_pos
= strchr (signature_pos
, '$');
16578 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16580 u32 signature_len
= salt_pos
- signature_pos
;
16582 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16586 char *hash_pos
= strchr (salt_pos
, '$');
16588 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 salt_len
= hash_pos
- salt_pos
;
16592 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16596 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16598 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16600 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16601 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16602 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16603 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16604 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16606 digest
[0] -= SHA1M_A
;
16607 digest
[1] -= SHA1M_B
;
16608 digest
[2] -= SHA1M_C
;
16609 digest
[3] -= SHA1M_D
;
16610 digest
[4] -= SHA1M_E
;
16612 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16614 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16616 salt
->salt_len
= salt_len
;
16618 return (PARSER_OK
);
16621 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16623 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16625 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16627 u32
*digest
= (u32
*) hash_buf
->digest
;
16629 salt_t
*salt
= hash_buf
->salt
;
16631 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16637 char *iter_pos
= input_buf
+ 14;
16639 const int iter
= atoi (iter_pos
);
16641 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16643 salt
->salt_iter
= iter
- 1;
16645 char *salt_pos
= strchr (iter_pos
, '$');
16647 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16651 char *hash_pos
= strchr (salt_pos
, '$');
16653 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16655 const uint salt_len
= hash_pos
- salt_pos
;
16659 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16661 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16663 salt
->salt_len
= salt_len
;
16665 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16666 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16668 // add some stuff to normal salt to make sorted happy
16670 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16671 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16672 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16673 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16674 salt
->salt_buf
[4] = salt
->salt_iter
;
16676 // base64 decode hash
16678 u8 tmp_buf
[100] = { 0 };
16680 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16682 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16684 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16686 memcpy (digest
, tmp_buf
, 32);
16688 digest
[0] = byte_swap_32 (digest
[0]);
16689 digest
[1] = byte_swap_32 (digest
[1]);
16690 digest
[2] = byte_swap_32 (digest
[2]);
16691 digest
[3] = byte_swap_32 (digest
[3]);
16692 digest
[4] = byte_swap_32 (digest
[4]);
16693 digest
[5] = byte_swap_32 (digest
[5]);
16694 digest
[6] = byte_swap_32 (digest
[6]);
16695 digest
[7] = byte_swap_32 (digest
[7]);
16697 return (PARSER_OK
);
16700 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16702 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16704 u32
*digest
= (u32
*) hash_buf
->digest
;
16706 salt_t
*salt
= hash_buf
->salt
;
16708 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16709 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16713 digest
[0] = byte_swap_32 (digest
[0]);
16714 digest
[1] = byte_swap_32 (digest
[1]);
16716 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16717 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16718 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 char iter_c
= input_buf
[17];
16721 char iter_d
= input_buf
[19];
16723 // atm only defaults, let's see if there's more request
16724 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16725 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16727 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16729 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16730 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16731 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16732 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16734 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16735 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16736 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16737 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16739 salt
->salt_len
= 16;
16741 return (PARSER_OK
);
16744 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16746 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16748 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16750 u32
*digest
= (u32
*) hash_buf
->digest
;
16752 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16754 salt_t
*salt
= hash_buf
->salt
;
16756 char *salt_pos
= input_buf
+ 10;
16758 char *hash_pos
= strchr (salt_pos
, '$');
16760 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16762 uint salt_len
= hash_pos
- salt_pos
;
16766 uint hash_len
= input_len
- 10 - salt_len
- 1;
16768 // base64 decode salt
16770 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16772 u8 tmp_buf
[100] = { 0 };
16774 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16776 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16778 tmp_buf
[salt_len
] = 0x80;
16780 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16782 salt
->salt_len
= salt_len
;
16784 // base64 decode hash
16786 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16788 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16790 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16792 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16794 uint user_len
= hash_len
- 32;
16796 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16798 user_len
--; // skip the trailing space
16800 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16801 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16802 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16803 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16805 digest
[0] = byte_swap_32 (digest
[0]);
16806 digest
[1] = byte_swap_32 (digest
[1]);
16807 digest
[2] = byte_swap_32 (digest
[2]);
16808 digest
[3] = byte_swap_32 (digest
[3]);
16810 // store username for host only (output hash if cracked)
16812 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16813 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16815 return (PARSER_OK
);
16818 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16820 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16822 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16824 u32
*digest
= (u32
*) hash_buf
->digest
;
16826 salt_t
*salt
= hash_buf
->salt
;
16828 char *iter_pos
= input_buf
+ 10;
16830 u32 iter
= atoi (iter_pos
);
16834 return (PARSER_SALT_ITERATION
);
16837 iter
--; // first iteration is special
16839 salt
->salt_iter
= iter
;
16841 char *base64_pos
= strchr (iter_pos
, '}');
16843 if (base64_pos
== NULL
)
16845 return (PARSER_SIGNATURE_UNMATCHED
);
16850 // base64 decode salt
16852 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16854 u8 tmp_buf
[100] = { 0 };
16856 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16858 if (decoded_len
< 24)
16860 return (PARSER_SALT_LENGTH
);
16865 uint salt_len
= decoded_len
- 20;
16867 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16868 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16870 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16872 salt
->salt_len
= salt_len
;
16876 u32
*digest_ptr
= (u32
*) tmp_buf
;
16878 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16879 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16880 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16881 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16882 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16884 return (PARSER_OK
);
16887 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16889 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16891 u32
*digest
= (u32
*) hash_buf
->digest
;
16893 salt_t
*salt
= hash_buf
->salt
;
16895 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16896 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16897 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16898 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16899 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16901 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16903 uint salt_len
= input_len
- 40 - 1;
16905 char *salt_buf
= input_buf
+ 40 + 1;
16907 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16909 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16911 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16913 salt
->salt_len
= salt_len
;
16915 return (PARSER_OK
);
16918 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16920 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16922 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16924 u32
*digest
= (u32
*) hash_buf
->digest
;
16926 salt_t
*salt
= hash_buf
->salt
;
16928 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16934 char *V_pos
= input_buf
+ 5;
16936 char *R_pos
= strchr (V_pos
, '*');
16938 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16940 u32 V_len
= R_pos
- V_pos
;
16944 char *bits_pos
= strchr (R_pos
, '*');
16946 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16948 u32 R_len
= bits_pos
- R_pos
;
16952 char *P_pos
= strchr (bits_pos
, '*');
16954 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16956 u32 bits_len
= P_pos
- bits_pos
;
16960 char *enc_md_pos
= strchr (P_pos
, '*');
16962 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16964 u32 P_len
= enc_md_pos
- P_pos
;
16968 char *id_len_pos
= strchr (enc_md_pos
, '*');
16970 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16972 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16976 char *id_buf_pos
= strchr (id_len_pos
, '*');
16978 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16980 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16984 char *u_len_pos
= strchr (id_buf_pos
, '*');
16986 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16988 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16990 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16994 char *u_buf_pos
= strchr (u_len_pos
, '*');
16996 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16998 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17002 char *o_len_pos
= strchr (u_buf_pos
, '*');
17004 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17006 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17008 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17012 char *o_buf_pos
= strchr (o_len_pos
, '*');
17014 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17016 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17020 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;
17022 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17026 const int V
= atoi (V_pos
);
17027 const int R
= atoi (R_pos
);
17028 const int P
= atoi (P_pos
);
17030 if (V
!= 1) return (PARSER_SALT_VALUE
);
17031 if (R
!= 2) return (PARSER_SALT_VALUE
);
17033 const int enc_md
= atoi (enc_md_pos
);
17035 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17037 const int id_len
= atoi (id_len_pos
);
17038 const int u_len
= atoi (u_len_pos
);
17039 const int o_len
= atoi (o_len_pos
);
17041 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17042 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17043 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17045 const int bits
= atoi (bits_pos
);
17047 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17049 // copy data to esalt
17055 pdf
->enc_md
= enc_md
;
17057 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17058 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17059 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17060 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17061 pdf
->id_len
= id_len
;
17063 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17064 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17065 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17066 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17067 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17068 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17069 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17070 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17071 pdf
->u_len
= u_len
;
17073 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17074 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17075 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17076 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17077 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17078 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17079 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17080 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17081 pdf
->o_len
= o_len
;
17083 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17084 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17085 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17086 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17088 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17089 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17090 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17091 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17092 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17093 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17094 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17095 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17097 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17098 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17099 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17100 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17101 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17102 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17103 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17104 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17106 // we use ID for salt, maybe needs to change, we will see...
17108 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17109 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17110 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17111 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17112 salt
->salt_len
= pdf
->id_len
;
17114 digest
[0] = pdf
->u_buf
[0];
17115 digest
[1] = pdf
->u_buf
[1];
17116 digest
[2] = pdf
->u_buf
[2];
17117 digest
[3] = pdf
->u_buf
[3];
17119 return (PARSER_OK
);
17122 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17124 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17127 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17129 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17131 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17133 u32
*digest
= (u32
*) hash_buf
->digest
;
17135 salt_t
*salt
= hash_buf
->salt
;
17137 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17143 char *V_pos
= input_buf
+ 5;
17145 char *R_pos
= strchr (V_pos
, '*');
17147 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 u32 V_len
= R_pos
- V_pos
;
17153 char *bits_pos
= strchr (R_pos
, '*');
17155 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 u32 R_len
= bits_pos
- R_pos
;
17161 char *P_pos
= strchr (bits_pos
, '*');
17163 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 u32 bits_len
= P_pos
- bits_pos
;
17169 char *enc_md_pos
= strchr (P_pos
, '*');
17171 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 u32 P_len
= enc_md_pos
- P_pos
;
17177 char *id_len_pos
= strchr (enc_md_pos
, '*');
17179 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17181 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17185 char *id_buf_pos
= strchr (id_len_pos
, '*');
17187 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17189 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17193 char *u_len_pos
= strchr (id_buf_pos
, '*');
17195 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17197 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17199 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17203 char *u_buf_pos
= strchr (u_len_pos
, '*');
17205 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17207 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17211 char *o_len_pos
= strchr (u_buf_pos
, '*');
17213 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17215 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17217 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17221 char *o_buf_pos
= strchr (o_len_pos
, '*');
17223 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17225 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17229 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17231 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17233 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17235 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17239 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;
17241 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17245 const int V
= atoi (V_pos
);
17246 const int R
= atoi (R_pos
);
17247 const int P
= atoi (P_pos
);
17249 if (V
!= 1) return (PARSER_SALT_VALUE
);
17250 if (R
!= 2) return (PARSER_SALT_VALUE
);
17252 const int enc_md
= atoi (enc_md_pos
);
17254 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17256 const int id_len
= atoi (id_len_pos
);
17257 const int u_len
= atoi (u_len_pos
);
17258 const int o_len
= atoi (o_len_pos
);
17260 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17261 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17262 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17264 const int bits
= atoi (bits_pos
);
17266 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17268 // copy data to esalt
17274 pdf
->enc_md
= enc_md
;
17276 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17277 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17278 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17279 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17280 pdf
->id_len
= id_len
;
17282 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17283 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17284 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17285 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17286 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17287 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17288 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17289 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17290 pdf
->u_len
= u_len
;
17292 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17293 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17294 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17295 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17296 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17297 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17298 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17299 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17300 pdf
->o_len
= o_len
;
17302 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17303 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17304 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17305 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17307 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17308 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17309 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17310 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17311 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17312 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17313 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17314 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17316 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17317 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17318 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17319 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17320 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17321 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17322 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17323 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17325 pdf
->rc4key
[1] = 0;
17326 pdf
->rc4key
[0] = 0;
17328 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17329 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17330 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17331 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17332 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17333 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17334 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17335 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17336 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17337 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17339 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17340 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17342 // we use ID for salt, maybe needs to change, we will see...
17344 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17345 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17346 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17347 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17348 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17349 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17350 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17351 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17352 salt
->salt_len
= pdf
->id_len
+ 16;
17354 digest
[0] = pdf
->rc4key
[0];
17355 digest
[1] = pdf
->rc4key
[1];
17359 return (PARSER_OK
);
17362 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17364 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17366 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17368 u32
*digest
= (u32
*) hash_buf
->digest
;
17370 salt_t
*salt
= hash_buf
->salt
;
17372 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17378 char *V_pos
= input_buf
+ 5;
17380 char *R_pos
= strchr (V_pos
, '*');
17382 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17384 u32 V_len
= R_pos
- V_pos
;
17388 char *bits_pos
= strchr (R_pos
, '*');
17390 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17392 u32 R_len
= bits_pos
- R_pos
;
17396 char *P_pos
= strchr (bits_pos
, '*');
17398 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17400 u32 bits_len
= P_pos
- bits_pos
;
17404 char *enc_md_pos
= strchr (P_pos
, '*');
17406 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17408 u32 P_len
= enc_md_pos
- P_pos
;
17412 char *id_len_pos
= strchr (enc_md_pos
, '*');
17414 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17416 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17420 char *id_buf_pos
= strchr (id_len_pos
, '*');
17422 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17424 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17428 char *u_len_pos
= strchr (id_buf_pos
, '*');
17430 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17432 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17434 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17438 char *u_buf_pos
= strchr (u_len_pos
, '*');
17440 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17442 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17446 char *o_len_pos
= strchr (u_buf_pos
, '*');
17448 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17450 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17452 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17456 char *o_buf_pos
= strchr (o_len_pos
, '*');
17458 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17460 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17464 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;
17466 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17470 const int V
= atoi (V_pos
);
17471 const int R
= atoi (R_pos
);
17472 const int P
= atoi (P_pos
);
17476 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17477 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17479 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17481 const int id_len
= atoi (id_len_pos
);
17482 const int u_len
= atoi (u_len_pos
);
17483 const int o_len
= atoi (o_len_pos
);
17485 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17487 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17488 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17490 const int bits
= atoi (bits_pos
);
17492 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17498 enc_md
= atoi (enc_md_pos
);
17501 // copy data to esalt
17507 pdf
->enc_md
= enc_md
;
17509 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17510 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17511 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17512 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17516 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17517 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17518 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17519 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17522 pdf
->id_len
= id_len
;
17524 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17525 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17526 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17527 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17528 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17529 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17530 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17531 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17532 pdf
->u_len
= u_len
;
17534 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17535 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17536 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17537 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17538 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17539 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17540 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17541 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17542 pdf
->o_len
= o_len
;
17544 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17545 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17546 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17547 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17551 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17552 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17553 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17554 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17557 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17558 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17559 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17560 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17561 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17562 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17563 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17564 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17566 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17567 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17568 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17569 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17570 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17571 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17572 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17573 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17575 // precompute rc4 data for later use
17591 uint salt_pc_block
[32] = { 0 };
17593 char *salt_pc_ptr
= (char *) salt_pc_block
;
17595 memcpy (salt_pc_ptr
, padding
, 32);
17596 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17598 uint salt_pc_digest
[4] = { 0 };
17600 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17602 pdf
->rc4data
[0] = salt_pc_digest
[0];
17603 pdf
->rc4data
[1] = salt_pc_digest
[1];
17605 // we use ID for salt, maybe needs to change, we will see...
17607 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17608 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17609 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17610 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17611 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17612 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17613 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17614 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17615 salt
->salt_len
= pdf
->id_len
+ 16;
17617 salt
->salt_iter
= ROUNDS_PDF14
;
17619 digest
[0] = pdf
->u_buf
[0];
17620 digest
[1] = pdf
->u_buf
[1];
17624 return (PARSER_OK
);
17627 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17629 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17631 if (ret
!= PARSER_OK
)
17636 u32
*digest
= (u32
*) hash_buf
->digest
;
17638 salt_t
*salt
= hash_buf
->salt
;
17640 digest
[0] -= SHA256M_A
;
17641 digest
[1] -= SHA256M_B
;
17642 digest
[2] -= SHA256M_C
;
17643 digest
[3] -= SHA256M_D
;
17644 digest
[4] -= SHA256M_E
;
17645 digest
[5] -= SHA256M_F
;
17646 digest
[6] -= SHA256M_G
;
17647 digest
[7] -= SHA256M_H
;
17649 salt
->salt_buf
[2] = 0x80;
17651 return (PARSER_OK
);
17654 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17656 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17658 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17660 u32
*digest
= (u32
*) hash_buf
->digest
;
17662 salt_t
*salt
= hash_buf
->salt
;
17664 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17670 char *V_pos
= input_buf
+ 5;
17672 char *R_pos
= strchr (V_pos
, '*');
17674 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17676 u32 V_len
= R_pos
- V_pos
;
17680 char *bits_pos
= strchr (R_pos
, '*');
17682 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17684 u32 R_len
= bits_pos
- R_pos
;
17688 char *P_pos
= strchr (bits_pos
, '*');
17690 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17692 u32 bits_len
= P_pos
- bits_pos
;
17696 char *enc_md_pos
= strchr (P_pos
, '*');
17698 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17700 u32 P_len
= enc_md_pos
- P_pos
;
17704 char *id_len_pos
= strchr (enc_md_pos
, '*');
17706 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17708 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17712 char *id_buf_pos
= strchr (id_len_pos
, '*');
17714 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17716 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17720 char *u_len_pos
= strchr (id_buf_pos
, '*');
17722 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17724 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17728 char *u_buf_pos
= strchr (u_len_pos
, '*');
17730 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17732 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17736 char *o_len_pos
= strchr (u_buf_pos
, '*');
17738 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17740 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17744 char *o_buf_pos
= strchr (o_len_pos
, '*');
17746 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17748 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17752 char *last
= strchr (o_buf_pos
, '*');
17754 if (last
== NULL
) last
= input_buf
+ input_len
;
17756 u32 o_buf_len
= last
- o_buf_pos
;
17760 const int V
= atoi (V_pos
);
17761 const int R
= atoi (R_pos
);
17765 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17766 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17768 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17770 const int bits
= atoi (bits_pos
);
17772 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17774 int enc_md
= atoi (enc_md_pos
);
17776 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17778 const uint id_len
= atoi (id_len_pos
);
17779 const uint u_len
= atoi (u_len_pos
);
17780 const uint o_len
= atoi (o_len_pos
);
17782 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17783 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17784 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17785 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17786 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17787 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17788 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17789 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17791 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17792 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17793 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17795 // copy data to esalt
17797 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17799 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17801 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17804 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17805 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17807 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17808 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17810 salt
->salt_len
= 8;
17811 salt
->salt_iter
= ROUNDS_PDF17L8
;
17813 digest
[0] = pdf
->u_buf
[0];
17814 digest
[1] = pdf
->u_buf
[1];
17815 digest
[2] = pdf
->u_buf
[2];
17816 digest
[3] = pdf
->u_buf
[3];
17817 digest
[4] = pdf
->u_buf
[4];
17818 digest
[5] = pdf
->u_buf
[5];
17819 digest
[6] = pdf
->u_buf
[6];
17820 digest
[7] = pdf
->u_buf
[7];
17822 return (PARSER_OK
);
17825 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17827 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17829 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17831 u32
*digest
= (u32
*) hash_buf
->digest
;
17833 salt_t
*salt
= hash_buf
->salt
;
17835 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17843 char *iter_pos
= input_buf
+ 7;
17845 u32 iter
= atoi (iter_pos
);
17847 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17848 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17850 // first is *raw* salt
17852 char *salt_pos
= strchr (iter_pos
, ':');
17854 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17858 char *hash_pos
= strchr (salt_pos
, ':');
17860 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17862 u32 salt_len
= hash_pos
- salt_pos
;
17864 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17868 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17870 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17874 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17876 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17878 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17880 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17881 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17883 salt
->salt_len
= salt_len
;
17884 salt
->salt_iter
= iter
- 1;
17888 u8 tmp_buf
[100] = { 0 };
17890 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17892 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17894 memcpy (digest
, tmp_buf
, 16);
17896 digest
[0] = byte_swap_32 (digest
[0]);
17897 digest
[1] = byte_swap_32 (digest
[1]);
17898 digest
[2] = byte_swap_32 (digest
[2]);
17899 digest
[3] = byte_swap_32 (digest
[3]);
17901 // add some stuff to normal salt to make sorted happy
17903 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17904 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17905 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17906 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17907 salt
->salt_buf
[4] = salt
->salt_iter
;
17909 return (PARSER_OK
);
17912 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17914 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17916 u32
*digest
= (u32
*) hash_buf
->digest
;
17918 salt_t
*salt
= hash_buf
->salt
;
17920 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17921 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17922 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17923 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17925 digest
[0] = byte_swap_32 (digest
[0]);
17926 digest
[1] = byte_swap_32 (digest
[1]);
17927 digest
[2] = byte_swap_32 (digest
[2]);
17928 digest
[3] = byte_swap_32 (digest
[3]);
17930 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17932 uint salt_len
= input_len
- 32 - 1;
17934 char *salt_buf
= input_buf
+ 32 + 1;
17936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17938 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17942 salt
->salt_len
= salt_len
;
17944 return (PARSER_OK
);
17947 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17949 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17951 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17953 u32
*digest
= (u32
*) hash_buf
->digest
;
17955 salt_t
*salt
= hash_buf
->salt
;
17957 char *user_pos
= input_buf
+ 10;
17959 char *salt_pos
= strchr (user_pos
, '*');
17961 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17965 char *hash_pos
= strchr (salt_pos
, '*');
17969 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17971 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17973 uint user_len
= salt_pos
- user_pos
- 1;
17975 uint salt_len
= hash_pos
- salt_pos
- 1;
17977 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17983 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17984 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17985 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17986 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17988 digest
[0] = byte_swap_32 (digest
[0]);
17989 digest
[1] = byte_swap_32 (digest
[1]);
17990 digest
[2] = byte_swap_32 (digest
[2]);
17991 digest
[3] = byte_swap_32 (digest
[3]);
17993 digest
[0] -= MD5M_A
;
17994 digest
[1] -= MD5M_B
;
17995 digest
[2] -= MD5M_C
;
17996 digest
[3] -= MD5M_D
;
18002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18004 // first 4 bytes are the "challenge"
18006 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18007 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18008 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18009 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18011 // append the user name
18013 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18015 salt
->salt_len
= 4 + user_len
;
18017 return (PARSER_OK
);
18020 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18022 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18024 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18026 u32
*digest
= (u32
*) hash_buf
->digest
;
18028 salt_t
*salt
= hash_buf
->salt
;
18030 char *salt_pos
= input_buf
+ 9;
18032 char *hash_pos
= strchr (salt_pos
, '*');
18034 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18038 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18040 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18042 uint salt_len
= hash_pos
- salt_pos
- 1;
18044 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18050 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18051 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18052 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18053 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18054 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18060 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18062 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18064 salt
->salt_len
= salt_len
;
18066 return (PARSER_OK
);
18069 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18071 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18073 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18075 u32
*digest
= (u32
*) hash_buf
->digest
;
18077 salt_t
*salt
= hash_buf
->salt
;
18079 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18085 char *cry_master_len_pos
= input_buf
+ 9;
18087 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18089 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18091 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18093 cry_master_buf_pos
++;
18095 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18097 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18099 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18101 cry_salt_len_pos
++;
18103 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18105 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18107 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18109 cry_salt_buf_pos
++;
18111 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18113 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18115 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18119 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18121 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18123 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18127 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18129 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18131 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18135 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18137 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18139 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18141 public_key_len_pos
++;
18143 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18145 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18147 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18149 public_key_buf_pos
++;
18151 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;
18153 const uint cry_master_len
= atoi (cry_master_len_pos
);
18154 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18155 const uint ckey_len
= atoi (ckey_len_pos
);
18156 const uint public_key_len
= atoi (public_key_len_pos
);
18158 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18159 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18160 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18161 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18163 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18165 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18167 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18170 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18172 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18174 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18177 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18179 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18181 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18184 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18185 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18186 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18189 * store digest (should be unique enought, hopefully)
18192 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18193 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18194 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18195 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18201 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18203 const uint cry_rounds
= atoi (cry_rounds_pos
);
18205 salt
->salt_iter
= cry_rounds
- 1;
18207 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18209 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18211 salt
->salt_len
= salt_len
;
18213 return (PARSER_OK
);
18216 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18218 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18220 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18222 u32
*digest
= (u32
*) hash_buf
->digest
;
18224 salt_t
*salt
= hash_buf
->salt
;
18226 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18228 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18230 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18232 memcpy (temp_input_buf
, input_buf
, input_len
);
18236 char *URI_server_pos
= temp_input_buf
+ 6;
18238 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18240 if (URI_client_pos
== NULL
)
18242 myfree (temp_input_buf
);
18244 return (PARSER_SEPARATOR_UNMATCHED
);
18247 URI_client_pos
[0] = 0;
18250 uint URI_server_len
= strlen (URI_server_pos
);
18252 if (URI_server_len
> 512)
18254 myfree (temp_input_buf
);
18256 return (PARSER_SALT_LENGTH
);
18261 char *user_pos
= strchr (URI_client_pos
, '*');
18263 if (user_pos
== NULL
)
18265 myfree (temp_input_buf
);
18267 return (PARSER_SEPARATOR_UNMATCHED
);
18273 uint URI_client_len
= strlen (URI_client_pos
);
18275 if (URI_client_len
> 512)
18277 myfree (temp_input_buf
);
18279 return (PARSER_SALT_LENGTH
);
18284 char *realm_pos
= strchr (user_pos
, '*');
18286 if (realm_pos
== NULL
)
18288 myfree (temp_input_buf
);
18290 return (PARSER_SEPARATOR_UNMATCHED
);
18296 uint user_len
= strlen (user_pos
);
18298 if (user_len
> 116)
18300 myfree (temp_input_buf
);
18302 return (PARSER_SALT_LENGTH
);
18307 char *method_pos
= strchr (realm_pos
, '*');
18309 if (method_pos
== NULL
)
18311 myfree (temp_input_buf
);
18313 return (PARSER_SEPARATOR_UNMATCHED
);
18319 uint realm_len
= strlen (realm_pos
);
18321 if (realm_len
> 116)
18323 myfree (temp_input_buf
);
18325 return (PARSER_SALT_LENGTH
);
18330 char *URI_prefix_pos
= strchr (method_pos
, '*');
18332 if (URI_prefix_pos
== NULL
)
18334 myfree (temp_input_buf
);
18336 return (PARSER_SEPARATOR_UNMATCHED
);
18339 URI_prefix_pos
[0] = 0;
18342 uint method_len
= strlen (method_pos
);
18344 if (method_len
> 246)
18346 myfree (temp_input_buf
);
18348 return (PARSER_SALT_LENGTH
);
18353 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18355 if (URI_resource_pos
== NULL
)
18357 myfree (temp_input_buf
);
18359 return (PARSER_SEPARATOR_UNMATCHED
);
18362 URI_resource_pos
[0] = 0;
18363 URI_resource_pos
++;
18365 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18367 if (URI_prefix_len
> 245)
18369 myfree (temp_input_buf
);
18371 return (PARSER_SALT_LENGTH
);
18376 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18378 if (URI_suffix_pos
== NULL
)
18380 myfree (temp_input_buf
);
18382 return (PARSER_SEPARATOR_UNMATCHED
);
18385 URI_suffix_pos
[0] = 0;
18388 uint URI_resource_len
= strlen (URI_resource_pos
);
18390 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18392 myfree (temp_input_buf
);
18394 return (PARSER_SALT_LENGTH
);
18399 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18401 if (nonce_pos
== NULL
)
18403 myfree (temp_input_buf
);
18405 return (PARSER_SEPARATOR_UNMATCHED
);
18411 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18413 if (URI_suffix_len
> 245)
18415 myfree (temp_input_buf
);
18417 return (PARSER_SALT_LENGTH
);
18422 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18424 if (nonce_client_pos
== NULL
)
18426 myfree (temp_input_buf
);
18428 return (PARSER_SEPARATOR_UNMATCHED
);
18431 nonce_client_pos
[0] = 0;
18432 nonce_client_pos
++;
18434 uint nonce_len
= strlen (nonce_pos
);
18436 if (nonce_len
< 1 || nonce_len
> 50)
18438 myfree (temp_input_buf
);
18440 return (PARSER_SALT_LENGTH
);
18445 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18447 if (nonce_count_pos
== NULL
)
18449 myfree (temp_input_buf
);
18451 return (PARSER_SEPARATOR_UNMATCHED
);
18454 nonce_count_pos
[0] = 0;
18457 uint nonce_client_len
= strlen (nonce_client_pos
);
18459 if (nonce_client_len
> 50)
18461 myfree (temp_input_buf
);
18463 return (PARSER_SALT_LENGTH
);
18468 char *qop_pos
= strchr (nonce_count_pos
, '*');
18470 if (qop_pos
== NULL
)
18472 myfree (temp_input_buf
);
18474 return (PARSER_SEPARATOR_UNMATCHED
);
18480 uint nonce_count_len
= strlen (nonce_count_pos
);
18482 if (nonce_count_len
> 50)
18484 myfree (temp_input_buf
);
18486 return (PARSER_SALT_LENGTH
);
18491 char *directive_pos
= strchr (qop_pos
, '*');
18493 if (directive_pos
== NULL
)
18495 myfree (temp_input_buf
);
18497 return (PARSER_SEPARATOR_UNMATCHED
);
18500 directive_pos
[0] = 0;
18503 uint qop_len
= strlen (qop_pos
);
18507 myfree (temp_input_buf
);
18509 return (PARSER_SALT_LENGTH
);
18514 char *digest_pos
= strchr (directive_pos
, '*');
18516 if (digest_pos
== NULL
)
18518 myfree (temp_input_buf
);
18520 return (PARSER_SEPARATOR_UNMATCHED
);
18526 uint directive_len
= strlen (directive_pos
);
18528 if (directive_len
!= 3)
18530 myfree (temp_input_buf
);
18532 return (PARSER_SALT_LENGTH
);
18535 if (memcmp (directive_pos
, "MD5", 3))
18537 log_info ("ERROR: only the MD5 directive is currently supported\n");
18539 myfree (temp_input_buf
);
18541 return (PARSER_SIP_AUTH_DIRECTIVE
);
18545 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18550 uint md5_max_len
= 4 * 64;
18552 uint md5_remaining_len
= md5_max_len
;
18554 uint tmp_md5_buf
[64] = { 0 };
18556 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18558 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18560 md5_len
+= method_len
+ 1;
18561 tmp_md5_ptr
+= method_len
+ 1;
18563 if (URI_prefix_len
> 0)
18565 md5_remaining_len
= md5_max_len
- md5_len
;
18567 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18569 md5_len
+= URI_prefix_len
+ 1;
18570 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18573 md5_remaining_len
= md5_max_len
- md5_len
;
18575 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18577 md5_len
+= URI_resource_len
;
18578 tmp_md5_ptr
+= URI_resource_len
;
18580 if (URI_suffix_len
> 0)
18582 md5_remaining_len
= md5_max_len
- md5_len
;
18584 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18586 md5_len
+= 1 + URI_suffix_len
;
18589 uint tmp_digest
[4] = { 0 };
18591 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18593 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18594 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18595 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18596 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18602 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18604 uint esalt_len
= 0;
18606 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18608 // there are 2 possibilities for the esalt:
18610 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18612 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18614 if (esalt_len
> max_esalt_len
)
18616 myfree (temp_input_buf
);
18618 return (PARSER_SALT_LENGTH
);
18621 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18633 esalt_len
= 1 + nonce_len
+ 1 + 32;
18635 if (esalt_len
> max_esalt_len
)
18637 myfree (temp_input_buf
);
18639 return (PARSER_SALT_LENGTH
);
18642 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18650 // add 0x80 to esalt
18652 esalt_buf_ptr
[esalt_len
] = 0x80;
18654 sip
->esalt_len
= esalt_len
;
18660 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18662 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18664 uint max_salt_len
= 119;
18666 if (salt_len
> max_salt_len
)
18668 myfree (temp_input_buf
);
18670 return (PARSER_SALT_LENGTH
);
18673 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18675 sip
->salt_len
= salt_len
;
18678 * fake salt (for sorting)
18681 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18685 uint fake_salt_len
= salt_len
;
18687 if (fake_salt_len
> max_salt_len
)
18689 fake_salt_len
= max_salt_len
;
18692 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18694 salt
->salt_len
= fake_salt_len
;
18700 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18701 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18702 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18703 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18705 digest
[0] = byte_swap_32 (digest
[0]);
18706 digest
[1] = byte_swap_32 (digest
[1]);
18707 digest
[2] = byte_swap_32 (digest
[2]);
18708 digest
[3] = byte_swap_32 (digest
[3]);
18710 myfree (temp_input_buf
);
18712 return (PARSER_OK
);
18715 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18717 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18719 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18721 u32
*digest
= (u32
*) hash_buf
->digest
;
18723 salt_t
*salt
= hash_buf
->salt
;
18727 char *digest_pos
= input_buf
;
18729 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18736 char *salt_buf
= input_buf
+ 8 + 1;
18740 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18742 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18744 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18746 salt
->salt_len
= salt_len
;
18748 return (PARSER_OK
);
18751 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18753 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18755 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18757 u32
*digest
= (u32
*) hash_buf
->digest
;
18759 salt_t
*salt
= hash_buf
->salt
;
18761 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18767 char *p_buf_pos
= input_buf
+ 4;
18769 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18771 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18773 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18775 NumCyclesPower_pos
++;
18777 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18779 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18781 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18785 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18787 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18789 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18793 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18795 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18797 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18801 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18803 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18805 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18809 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18811 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18813 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18817 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18819 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18821 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18825 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18827 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18829 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18833 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18835 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18837 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18841 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;
18843 const uint iter
= atoi (NumCyclesPower_pos
);
18844 const uint crc
= atoi (crc_buf_pos
);
18845 const uint p_buf
= atoi (p_buf_pos
);
18846 const uint salt_len
= atoi (salt_len_pos
);
18847 const uint iv_len
= atoi (iv_len_pos
);
18848 const uint unpack_size
= atoi (unpack_size_pos
);
18849 const uint data_len
= atoi (data_len_pos
);
18855 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18856 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18858 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18860 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18862 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18868 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18869 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18870 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18871 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18873 seven_zip
->iv_len
= iv_len
;
18875 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18877 seven_zip
->salt_len
= 0;
18879 seven_zip
->crc
= crc
;
18881 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18883 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18885 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18888 seven_zip
->data_len
= data_len
;
18890 seven_zip
->unpack_size
= unpack_size
;
18894 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18895 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18896 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18897 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18899 salt
->salt_len
= 16;
18901 salt
->salt_sign
[0] = iter
;
18903 salt
->salt_iter
= 1 << iter
;
18914 return (PARSER_OK
);
18917 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18919 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18921 u32
*digest
= (u32
*) hash_buf
->digest
;
18923 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18924 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18925 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18926 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18927 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18928 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18929 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18930 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18932 digest
[0] = byte_swap_32 (digest
[0]);
18933 digest
[1] = byte_swap_32 (digest
[1]);
18934 digest
[2] = byte_swap_32 (digest
[2]);
18935 digest
[3] = byte_swap_32 (digest
[3]);
18936 digest
[4] = byte_swap_32 (digest
[4]);
18937 digest
[5] = byte_swap_32 (digest
[5]);
18938 digest
[6] = byte_swap_32 (digest
[6]);
18939 digest
[7] = byte_swap_32 (digest
[7]);
18941 return (PARSER_OK
);
18944 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18946 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18948 u32
*digest
= (u32
*) hash_buf
->digest
;
18950 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18951 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18952 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18953 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18954 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18955 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18956 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18957 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18958 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18959 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18960 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18961 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18962 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18963 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18964 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18965 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18967 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18968 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18969 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18970 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18971 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18972 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18973 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18974 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18975 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18976 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18977 digest
[10] = byte_swap_32 (digest
[10]);
18978 digest
[11] = byte_swap_32 (digest
[11]);
18979 digest
[12] = byte_swap_32 (digest
[12]);
18980 digest
[13] = byte_swap_32 (digest
[13]);
18981 digest
[14] = byte_swap_32 (digest
[14]);
18982 digest
[15] = byte_swap_32 (digest
[15]);
18984 return (PARSER_OK
);
18987 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18989 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18991 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18993 u32
*digest
= (u32
*) hash_buf
->digest
;
18995 salt_t
*salt
= hash_buf
->salt
;
18997 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19005 char *iter_pos
= input_buf
+ 4;
19007 u32 iter
= atoi (iter_pos
);
19009 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19010 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19012 // first is *raw* salt
19014 char *salt_pos
= strchr (iter_pos
, ':');
19016 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19020 char *hash_pos
= strchr (salt_pos
, ':');
19022 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19024 u32 salt_len
= hash_pos
- salt_pos
;
19026 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19030 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19032 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19036 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19038 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19040 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19042 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19043 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19045 salt
->salt_len
= salt_len
;
19046 salt
->salt_iter
= iter
- 1;
19050 u8 tmp_buf
[100] = { 0 };
19052 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19054 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19056 memcpy (digest
, tmp_buf
, 16);
19058 // add some stuff to normal salt to make sorted happy
19060 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19061 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19062 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19063 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19064 salt
->salt_buf
[4] = salt
->salt_iter
;
19066 return (PARSER_OK
);
19069 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19071 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19073 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19075 u32
*digest
= (u32
*) hash_buf
->digest
;
19077 salt_t
*salt
= hash_buf
->salt
;
19079 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19087 char *iter_pos
= input_buf
+ 5;
19089 u32 iter
= atoi (iter_pos
);
19091 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19092 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19094 // first is *raw* salt
19096 char *salt_pos
= strchr (iter_pos
, ':');
19098 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19102 char *hash_pos
= strchr (salt_pos
, ':');
19104 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19106 u32 salt_len
= hash_pos
- salt_pos
;
19108 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19112 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19114 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19118 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19122 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19124 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19125 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19127 salt
->salt_len
= salt_len
;
19128 salt
->salt_iter
= iter
- 1;
19132 u8 tmp_buf
[100] = { 0 };
19134 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19136 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19138 memcpy (digest
, tmp_buf
, 16);
19140 digest
[0] = byte_swap_32 (digest
[0]);
19141 digest
[1] = byte_swap_32 (digest
[1]);
19142 digest
[2] = byte_swap_32 (digest
[2]);
19143 digest
[3] = byte_swap_32 (digest
[3]);
19145 // add some stuff to normal salt to make sorted happy
19147 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19148 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19149 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19150 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19151 salt
->salt_buf
[4] = salt
->salt_iter
;
19153 return (PARSER_OK
);
19156 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19158 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19160 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19162 u64
*digest
= (u64
*) hash_buf
->digest
;
19164 salt_t
*salt
= hash_buf
->salt
;
19166 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19174 char *iter_pos
= input_buf
+ 7;
19176 u32 iter
= atoi (iter_pos
);
19178 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19179 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19181 // first is *raw* salt
19183 char *salt_pos
= strchr (iter_pos
, ':');
19185 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19189 char *hash_pos
= strchr (salt_pos
, ':');
19191 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19193 u32 salt_len
= hash_pos
- salt_pos
;
19195 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19199 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19201 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19205 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19211 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19212 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19214 salt
->salt_len
= salt_len
;
19215 salt
->salt_iter
= iter
- 1;
19219 u8 tmp_buf
[100] = { 0 };
19221 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19223 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19225 memcpy (digest
, tmp_buf
, 64);
19227 digest
[0] = byte_swap_64 (digest
[0]);
19228 digest
[1] = byte_swap_64 (digest
[1]);
19229 digest
[2] = byte_swap_64 (digest
[2]);
19230 digest
[3] = byte_swap_64 (digest
[3]);
19231 digest
[4] = byte_swap_64 (digest
[4]);
19232 digest
[5] = byte_swap_64 (digest
[5]);
19233 digest
[6] = byte_swap_64 (digest
[6]);
19234 digest
[7] = byte_swap_64 (digest
[7]);
19236 // add some stuff to normal salt to make sorted happy
19238 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19239 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19240 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19241 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19242 salt
->salt_buf
[4] = salt
->salt_iter
;
19244 return (PARSER_OK
);
19247 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19249 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19251 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19253 uint
*digest
= (uint
*) hash_buf
->digest
;
19255 salt_t
*salt
= hash_buf
->salt
;
19261 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19263 char *hash_pos
= strchr (salt_pos
, '$');
19265 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19267 u32 salt_len
= hash_pos
- salt_pos
;
19269 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19273 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19275 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19279 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19280 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19298 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19299 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19301 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19302 salt
->salt_len
= 8;
19304 return (PARSER_OK
);
19307 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19309 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19311 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19313 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19315 if (c19
& 3) return (PARSER_HASH_VALUE
);
19317 salt_t
*salt
= hash_buf
->salt
;
19319 u32
*digest
= (u32
*) hash_buf
->digest
;
19323 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19324 | itoa64_to_int (input_buf
[2]) << 6
19325 | itoa64_to_int (input_buf
[3]) << 12
19326 | itoa64_to_int (input_buf
[4]) << 18;
19330 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19331 | itoa64_to_int (input_buf
[6]) << 6
19332 | itoa64_to_int (input_buf
[7]) << 12
19333 | itoa64_to_int (input_buf
[8]) << 18;
19335 salt
->salt_len
= 4;
19337 u8 tmp_buf
[100] = { 0 };
19339 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19341 memcpy (digest
, tmp_buf
, 8);
19345 IP (digest
[0], digest
[1], tt
);
19347 digest
[0] = rotr32 (digest
[0], 31);
19348 digest
[1] = rotr32 (digest
[1], 31);
19352 return (PARSER_OK
);
19355 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19357 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19359 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19361 u32
*digest
= (u32
*) hash_buf
->digest
;
19363 salt_t
*salt
= hash_buf
->salt
;
19369 char *type_pos
= input_buf
+ 6 + 1;
19371 char *salt_pos
= strchr (type_pos
, '*');
19373 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19375 u32 type_len
= salt_pos
- type_pos
;
19377 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19381 char *crypted_pos
= strchr (salt_pos
, '*');
19383 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19385 u32 salt_len
= crypted_pos
- salt_pos
;
19387 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19391 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19393 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19399 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19400 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19402 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19403 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19405 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19406 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19407 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19408 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19410 salt
->salt_len
= 24;
19411 salt
->salt_iter
= ROUNDS_RAR3
;
19413 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19414 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19416 digest
[0] = 0xc43d7b00;
19417 digest
[1] = 0x40070000;
19421 return (PARSER_OK
);
19424 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19426 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19428 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19430 u32
*digest
= (u32
*) hash_buf
->digest
;
19432 salt_t
*salt
= hash_buf
->salt
;
19434 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19440 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19442 char *param1_pos
= strchr (param0_pos
, '$');
19444 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19446 u32 param0_len
= param1_pos
- param0_pos
;
19450 char *param2_pos
= strchr (param1_pos
, '$');
19452 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19454 u32 param1_len
= param2_pos
- param1_pos
;
19458 char *param3_pos
= strchr (param2_pos
, '$');
19460 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19462 u32 param2_len
= param3_pos
- param2_pos
;
19466 char *param4_pos
= strchr (param3_pos
, '$');
19468 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19470 u32 param3_len
= param4_pos
- param3_pos
;
19474 char *param5_pos
= strchr (param4_pos
, '$');
19476 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19478 u32 param4_len
= param5_pos
- param4_pos
;
19482 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19484 char *salt_buf
= param1_pos
;
19485 char *iv
= param3_pos
;
19486 char *pswcheck
= param5_pos
;
19488 const uint salt_len
= atoi (param0_pos
);
19489 const uint iterations
= atoi (param2_pos
);
19490 const uint pswcheck_len
= atoi (param4_pos
);
19496 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19497 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19498 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19500 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19501 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19502 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19508 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19509 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19510 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19511 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19513 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19514 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19515 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19516 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19518 salt
->salt_len
= 16;
19520 salt
->salt_sign
[0] = iterations
;
19522 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19528 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19529 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19533 return (PARSER_OK
);
19536 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19538 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19540 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19542 u32
*digest
= (u32
*) hash_buf
->digest
;
19544 salt_t
*salt
= hash_buf
->salt
;
19546 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19553 char *account_pos
= input_buf
+ 11 + 1;
19559 if (account_pos
[0] == '*')
19563 data_pos
= strchr (account_pos
, '*');
19568 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19570 uint account_len
= data_pos
- account_pos
+ 1;
19572 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19577 data_len
= input_len
- 11 - 1 - account_len
- 2;
19579 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19583 /* assume $krb5tgs$23$checksum$edata2 */
19584 data_pos
= account_pos
;
19586 memcpy (krb5tgs
->account_info
, "**", 3);
19588 data_len
= input_len
- 11 - 1 - 1;
19591 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19593 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19595 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19597 const char p0
= data_pos
[i
+ 0];
19598 const char p1
= data_pos
[i
+ 1];
19600 *checksum_ptr
++ = hex_convert (p1
) << 0
19601 | hex_convert (p0
) << 4;
19604 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19606 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19609 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19611 const char p0
= data_pos
[i
+ 0];
19612 const char p1
= data_pos
[i
+ 1];
19613 *edata_ptr
++ = hex_convert (p1
) << 0
19614 | hex_convert (p0
) << 4;
19617 /* this is needed for hmac_md5 */
19618 *edata_ptr
++ = 0x80;
19620 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19621 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19622 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19623 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19625 salt
->salt_len
= 32;
19627 digest
[0] = krb5tgs
->checksum
[0];
19628 digest
[1] = krb5tgs
->checksum
[1];
19629 digest
[2] = krb5tgs
->checksum
[2];
19630 digest
[3] = krb5tgs
->checksum
[3];
19632 return (PARSER_OK
);
19635 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19637 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19639 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19641 u32
*digest
= (u32
*) hash_buf
->digest
;
19643 salt_t
*salt
= hash_buf
->salt
;
19650 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19654 char *wrapped_key_pos
;
19658 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19660 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19662 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19664 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19669 data_pos
= salt_pos
;
19671 wrapped_key_pos
= strchr (salt_pos
, '*');
19673 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19675 uint salt_len
= wrapped_key_pos
- salt_pos
;
19677 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19682 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19684 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19686 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19687 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19688 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19689 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19693 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19694 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19695 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19696 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19697 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19698 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19700 salt
->salt_len
= 40;
19702 digest
[0] = salt
->salt_buf
[0];
19703 digest
[1] = salt
->salt_buf
[1];
19704 digest
[2] = salt
->salt_buf
[2];
19705 digest
[3] = salt
->salt_buf
[3];
19707 return (PARSER_OK
);
19710 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19712 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19714 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19716 u32
*digest
= (u32
*) hash_buf
->digest
;
19718 salt_t
*salt
= hash_buf
->salt
;
19720 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19730 char *algorithm_pos
;
19732 char *final_random_seed_pos
;
19733 u32 final_random_seed_len
;
19735 char *transf_random_seed_pos
;
19736 u32 transf_random_seed_len
;
19741 /* default is no keyfile provided */
19742 char *keyfile_len_pos
;
19743 u32 keyfile_len
= 0;
19744 u32 is_keyfile_present
= 0;
19745 char *keyfile_inline_pos
;
19748 /* specific to version 1 */
19749 char *contents_len_pos
;
19751 char *contents_pos
;
19753 /* specific to version 2 */
19754 char *expected_bytes_pos
;
19755 u32 expected_bytes_len
;
19757 char *contents_hash_pos
;
19758 u32 contents_hash_len
;
19760 version_pos
= input_buf
+ 8 + 1 + 1;
19762 keepass
->version
= atoi (version_pos
);
19764 rounds_pos
= strchr (version_pos
, '*');
19766 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19770 salt
->salt_iter
= (atoi (rounds_pos
));
19772 algorithm_pos
= strchr (rounds_pos
, '*');
19774 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19778 keepass
->algorithm
= atoi (algorithm_pos
);
19780 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19782 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19784 final_random_seed_pos
++;
19786 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19787 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19788 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19789 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19791 if (keepass
->version
== 2)
19793 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19794 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19795 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19796 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19799 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19801 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19803 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19805 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19806 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19808 transf_random_seed_pos
++;
19810 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19811 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19812 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19813 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19814 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19815 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19816 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19817 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19819 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19821 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19823 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19825 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19829 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19830 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19831 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19832 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19834 if (keepass
->version
== 1)
19836 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19838 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19840 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19842 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19844 contents_hash_pos
++;
19846 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19847 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19848 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19849 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19850 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19851 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19852 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19853 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19855 /* get length of contents following */
19856 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19858 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19860 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19862 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19866 u32 inline_flag
= atoi (inline_flag_pos
);
19868 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19870 contents_len_pos
= strchr (inline_flag_pos
, '*');
19872 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19874 contents_len_pos
++;
19876 contents_len
= atoi (contents_len_pos
);
19878 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19880 contents_pos
= strchr (contents_len_pos
, '*');
19882 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19888 keepass
->contents_len
= contents_len
;
19890 contents_len
= contents_len
/ 4;
19892 keyfile_inline_pos
= strchr (contents_pos
, '*');
19894 u32 real_contents_len
;
19896 if (keyfile_inline_pos
== NULL
)
19897 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19900 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19901 keyfile_inline_pos
++;
19902 is_keyfile_present
= 1;
19905 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19907 for (i
= 0; i
< contents_len
; i
++)
19908 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19910 else if (keepass
->version
== 2)
19912 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19914 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19916 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19918 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19920 expected_bytes_pos
++;
19922 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19923 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19924 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19925 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19926 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19927 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19928 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19929 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19931 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19933 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19935 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19937 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19939 contents_hash_pos
++;
19941 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19942 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19943 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19944 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19945 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19946 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19947 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19948 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19950 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19952 if (keyfile_inline_pos
== NULL
)
19953 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19956 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19957 keyfile_inline_pos
++;
19958 is_keyfile_present
= 1;
19960 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19963 if (is_keyfile_present
!= 0)
19965 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19969 keyfile_len
= atoi (keyfile_len_pos
);
19971 keepass
->keyfile_len
= keyfile_len
;
19973 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19975 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19977 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19981 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19983 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19985 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19986 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19987 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19988 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19989 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19990 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19991 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19992 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19995 digest
[0] = keepass
->enc_iv
[0];
19996 digest
[1] = keepass
->enc_iv
[1];
19997 digest
[2] = keepass
->enc_iv
[2];
19998 digest
[3] = keepass
->enc_iv
[3];
20000 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20001 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20002 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20003 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20004 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20005 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20006 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20007 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20009 return (PARSER_OK
);
20012 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20014 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20016 u32
*digest
= (u32
*) hash_buf
->digest
;
20018 salt_t
*salt
= hash_buf
->salt
;
20020 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20021 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20022 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20023 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20024 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20025 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20026 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20027 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20029 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20031 uint salt_len
= input_len
- 64 - 1;
20033 char *salt_buf
= input_buf
+ 64 + 1;
20035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20037 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20039 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20041 salt
->salt_len
= salt_len
;
20044 * we can precompute the first sha256 transform
20047 uint w
[16] = { 0 };
20049 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20050 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20051 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20052 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20053 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20054 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20055 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20056 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20057 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20058 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20059 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20060 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20061 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20062 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20063 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20064 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20066 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20068 sha256_64 (w
, pc256
);
20070 salt
->salt_buf_pc
[0] = pc256
[0];
20071 salt
->salt_buf_pc
[1] = pc256
[1];
20072 salt
->salt_buf_pc
[2] = pc256
[2];
20073 salt
->salt_buf_pc
[3] = pc256
[3];
20074 salt
->salt_buf_pc
[4] = pc256
[4];
20075 salt
->salt_buf_pc
[5] = pc256
[5];
20076 salt
->salt_buf_pc
[6] = pc256
[6];
20077 salt
->salt_buf_pc
[7] = pc256
[7];
20079 digest
[0] -= pc256
[0];
20080 digest
[1] -= pc256
[1];
20081 digest
[2] -= pc256
[2];
20082 digest
[3] -= pc256
[3];
20083 digest
[4] -= pc256
[4];
20084 digest
[5] -= pc256
[5];
20085 digest
[6] -= pc256
[6];
20086 digest
[7] -= pc256
[7];
20088 return (PARSER_OK
);
20091 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20093 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20095 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20097 u32
*digest
= (u32
*) hash_buf
->digest
;
20099 salt_t
*salt
= hash_buf
->salt
;
20105 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20107 char *data_buf_pos
= strchr (data_len_pos
, '$');
20109 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20111 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20113 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20114 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20118 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20120 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20122 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20124 u32 data_len
= atoi (data_len_pos
);
20126 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20132 char *salt_pos
= data_buf_pos
;
20134 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20135 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20136 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20137 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20139 // this is actually the CT, which is also the hash later (if matched)
20141 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20142 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20143 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20144 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20146 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20148 salt
->salt_iter
= 10 - 1;
20154 digest
[0] = salt
->salt_buf
[4];
20155 digest
[1] = salt
->salt_buf
[5];
20156 digest
[2] = salt
->salt_buf
[6];
20157 digest
[3] = salt
->salt_buf
[7];
20159 return (PARSER_OK
);
20162 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20164 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20166 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20168 u32
*digest
= (u32
*) hash_buf
->digest
;
20170 salt_t
*salt
= hash_buf
->salt
;
20176 char *salt_pos
= input_buf
+ 11 + 1;
20178 char *iter_pos
= strchr (salt_pos
, ',');
20180 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20182 u32 salt_len
= iter_pos
- salt_pos
;
20184 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20188 char *hash_pos
= strchr (iter_pos
, ',');
20190 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20192 u32 iter_len
= hash_pos
- iter_pos
;
20194 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20198 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20200 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20206 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20207 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20208 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20209 salt
->salt_buf
[3] = 0x00018000;
20211 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20212 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20213 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20214 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20216 salt
->salt_len
= salt_len
/ 2;
20218 salt
->salt_iter
= atoi (iter_pos
) - 1;
20224 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20225 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20226 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20227 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20228 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20229 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20230 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20231 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20233 return (PARSER_OK
);
20236 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20238 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20240 u32
*digest
= (u32
*) hash_buf
->digest
;
20242 salt_t
*salt
= hash_buf
->salt
;
20248 char *hash_pos
= input_buf
+ 64;
20249 char *salt1_pos
= input_buf
+ 128;
20250 char *salt2_pos
= input_buf
;
20256 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20257 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20258 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20259 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20261 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20262 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20263 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20264 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20266 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20267 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20268 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20269 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20271 salt
->salt_len
= 48;
20273 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20279 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20280 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20281 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20282 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20283 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20284 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20285 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20286 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20288 return (PARSER_OK
);
20291 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20293 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20295 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20296 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20298 u32
*digest
= (u32
*) hash_buf
->digest
;
20300 salt_t
*salt
= hash_buf
->salt
;
20302 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20308 char *param0_pos
= input_buf
+ 6 + 1;
20310 char *param1_pos
= strchr (param0_pos
, '*');
20312 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20314 u32 param0_len
= param1_pos
- param0_pos
;
20318 char *param2_pos
= strchr (param1_pos
, '*');
20320 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20322 u32 param1_len
= param2_pos
- param1_pos
;
20326 char *param3_pos
= strchr (param2_pos
, '*');
20328 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20330 u32 param2_len
= param3_pos
- param2_pos
;
20334 char *param4_pos
= strchr (param3_pos
, '*');
20336 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20338 u32 param3_len
= param4_pos
- param3_pos
;
20342 char *param5_pos
= strchr (param4_pos
, '*');
20344 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20346 u32 param4_len
= param5_pos
- param4_pos
;
20350 char *param6_pos
= strchr (param5_pos
, '*');
20352 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20354 u32 param5_len
= param6_pos
- param5_pos
;
20358 char *param7_pos
= strchr (param6_pos
, '*');
20360 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20362 u32 param6_len
= param7_pos
- param6_pos
;
20366 char *param8_pos
= strchr (param7_pos
, '*');
20368 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20370 u32 param7_len
= param8_pos
- param7_pos
;
20374 const uint type
= atoi (param0_pos
);
20375 const uint mode
= atoi (param1_pos
);
20376 const uint magic
= atoi (param2_pos
);
20378 char *salt_buf
= param3_pos
;
20380 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20382 const uint compress_length
= atoi (param5_pos
);
20384 char *data_buf
= param6_pos
;
20385 char *auth
= param7_pos
;
20391 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20393 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20395 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20397 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20399 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20401 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20403 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20405 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20407 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20409 if (type
!= 0) return (PARSER_SALT_VALUE
);
20411 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20413 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20415 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20423 zip2
->magic
= magic
;
20427 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20428 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20429 zip2
->salt_buf
[2] = 0;
20430 zip2
->salt_buf
[3] = 0;
20432 zip2
->salt_len
= 8;
20434 else if (mode
== 2)
20436 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20437 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20438 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20439 zip2
->salt_buf
[3] = 0;
20441 zip2
->salt_len
= 12;
20443 else if (mode
== 3)
20445 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20446 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20447 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20448 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20450 zip2
->salt_len
= 16;
20453 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20454 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20455 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20456 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20458 zip2
->verify_bytes
= verify_bytes
;
20460 zip2
->compress_length
= compress_length
;
20462 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20464 for (uint i
= 0; i
< param6_len
; i
+= 2)
20466 const char p0
= data_buf
[i
+ 0];
20467 const char p1
= data_buf
[i
+ 1];
20469 *data_buf_ptr
++ = hex_convert (p1
) << 0
20470 | hex_convert (p0
) << 4;
20475 *data_buf_ptr
= 0x80;
20477 char *auth_ptr
= (char *) zip2
->auth_buf
;
20479 for (uint i
= 0; i
< param7_len
; i
+= 2)
20481 const char p0
= auth
[i
+ 0];
20482 const char p1
= auth
[i
+ 1];
20484 *auth_ptr
++ = hex_convert (p1
) << 0
20485 | hex_convert (p0
) << 4;
20494 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20495 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20496 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20497 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20498 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20499 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20500 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20501 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20503 salt
->salt_len
= 32;
20505 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20508 * digest buf (fake)
20511 digest
[0] = zip2
->auth_buf
[0];
20512 digest
[1] = zip2
->auth_buf
[1];
20513 digest
[2] = zip2
->auth_buf
[2];
20514 digest
[3] = zip2
->auth_buf
[3];
20516 return (PARSER_OK
);
20520 * parallel running threads
20525 BOOL WINAPI
sigHandler_default (DWORD sig
)
20529 case CTRL_CLOSE_EVENT
:
20532 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20533 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20534 * function otherwise it is too late (e.g. after returning from this function)
20539 SetConsoleCtrlHandler (NULL
, TRUE
);
20546 case CTRL_LOGOFF_EVENT
:
20547 case CTRL_SHUTDOWN_EVENT
:
20551 SetConsoleCtrlHandler (NULL
, TRUE
);
20559 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20563 case CTRL_CLOSE_EVENT
:
20567 SetConsoleCtrlHandler (NULL
, TRUE
);
20574 case CTRL_LOGOFF_EVENT
:
20575 case CTRL_SHUTDOWN_EVENT
:
20579 SetConsoleCtrlHandler (NULL
, TRUE
);
20587 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20589 if (callback
== NULL
)
20591 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20595 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20601 void sigHandler_default (int sig
)
20605 signal (sig
, NULL
);
20608 void sigHandler_benchmark (int sig
)
20612 signal (sig
, NULL
);
20615 void hc_signal (void (callback
) (int))
20617 if (callback
== NULL
) callback
= SIG_DFL
;
20619 signal (SIGINT
, callback
);
20620 signal (SIGTERM
, callback
);
20621 signal (SIGABRT
, callback
);
20626 void status_display ();
20628 void *thread_keypress (void *p
)
20630 int benchmark
= *((int *) p
);
20632 uint quiet
= data
.quiet
;
20636 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20638 int ch
= tty_getchar();
20640 if (ch
== -1) break;
20642 if (ch
== 0) continue;
20644 //https://github.com/hashcat/hashcat/issues/302
20649 hc_thread_mutex_lock (mux_display
);
20665 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20666 if (quiet
== 0) fflush (stdout
);
20678 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20679 if (quiet
== 0) fflush (stdout
);
20691 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20692 if (quiet
== 0) fflush (stdout
);
20704 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20705 if (quiet
== 0) fflush (stdout
);
20713 if (benchmark
== 1) break;
20715 stop_at_checkpoint ();
20719 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20720 if (quiet
== 0) fflush (stdout
);
20728 if (benchmark
== 1)
20740 //https://github.com/hashcat/hashcat/issues/302
20745 hc_thread_mutex_unlock (mux_display
);
20757 bool class_num (const u8 c
)
20759 return ((c
>= '0') && (c
<= '9'));
20762 bool class_lower (const u8 c
)
20764 return ((c
>= 'a') && (c
<= 'z'));
20767 bool class_upper (const u8 c
)
20769 return ((c
>= 'A') && (c
<= 'Z'));
20772 bool class_alpha (const u8 c
)
20774 return (class_lower (c
) || class_upper (c
));
20777 int conv_ctoi (const u8 c
)
20783 else if (class_upper (c
))
20785 return c
- 'A' + 10;
20791 int conv_itoc (const u8 c
)
20799 return c
+ 'A' - 10;
20809 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20810 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20811 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20812 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20813 #define MAX_KERNEL_RULES 255
20814 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20815 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20816 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20818 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20819 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20820 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20821 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20823 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20828 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20830 switch (rule_buf
[rule_pos
])
20836 case RULE_OP_MANGLE_NOOP
:
20837 SET_NAME (rule
, rule_buf
[rule_pos
]);
20840 case RULE_OP_MANGLE_LREST
:
20841 SET_NAME (rule
, rule_buf
[rule_pos
]);
20844 case RULE_OP_MANGLE_UREST
:
20845 SET_NAME (rule
, rule_buf
[rule_pos
]);
20848 case RULE_OP_MANGLE_LREST_UFIRST
:
20849 SET_NAME (rule
, rule_buf
[rule_pos
]);
20852 case RULE_OP_MANGLE_UREST_LFIRST
:
20853 SET_NAME (rule
, rule_buf
[rule_pos
]);
20856 case RULE_OP_MANGLE_TREST
:
20857 SET_NAME (rule
, rule_buf
[rule_pos
]);
20860 case RULE_OP_MANGLE_TOGGLE_AT
:
20861 SET_NAME (rule
, rule_buf
[rule_pos
]);
20862 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20865 case RULE_OP_MANGLE_REVERSE
:
20866 SET_NAME (rule
, rule_buf
[rule_pos
]);
20869 case RULE_OP_MANGLE_DUPEWORD
:
20870 SET_NAME (rule
, rule_buf
[rule_pos
]);
20873 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20874 SET_NAME (rule
, rule_buf
[rule_pos
]);
20875 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20878 case RULE_OP_MANGLE_REFLECT
:
20879 SET_NAME (rule
, rule_buf
[rule_pos
]);
20882 case RULE_OP_MANGLE_ROTATE_LEFT
:
20883 SET_NAME (rule
, rule_buf
[rule_pos
]);
20886 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20887 SET_NAME (rule
, rule_buf
[rule_pos
]);
20890 case RULE_OP_MANGLE_APPEND
:
20891 SET_NAME (rule
, rule_buf
[rule_pos
]);
20892 SET_P0 (rule
, rule_buf
[rule_pos
]);
20895 case RULE_OP_MANGLE_PREPEND
:
20896 SET_NAME (rule
, rule_buf
[rule_pos
]);
20897 SET_P0 (rule
, rule_buf
[rule_pos
]);
20900 case RULE_OP_MANGLE_DELETE_FIRST
:
20901 SET_NAME (rule
, rule_buf
[rule_pos
]);
20904 case RULE_OP_MANGLE_DELETE_LAST
:
20905 SET_NAME (rule
, rule_buf
[rule_pos
]);
20908 case RULE_OP_MANGLE_DELETE_AT
:
20909 SET_NAME (rule
, rule_buf
[rule_pos
]);
20910 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20913 case RULE_OP_MANGLE_EXTRACT
:
20914 SET_NAME (rule
, rule_buf
[rule_pos
]);
20915 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20916 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20919 case RULE_OP_MANGLE_OMIT
:
20920 SET_NAME (rule
, rule_buf
[rule_pos
]);
20921 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20922 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20925 case RULE_OP_MANGLE_INSERT
:
20926 SET_NAME (rule
, rule_buf
[rule_pos
]);
20927 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20928 SET_P1 (rule
, rule_buf
[rule_pos
]);
20931 case RULE_OP_MANGLE_OVERSTRIKE
:
20932 SET_NAME (rule
, rule_buf
[rule_pos
]);
20933 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20934 SET_P1 (rule
, rule_buf
[rule_pos
]);
20937 case RULE_OP_MANGLE_TRUNCATE_AT
:
20938 SET_NAME (rule
, rule_buf
[rule_pos
]);
20939 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20942 case RULE_OP_MANGLE_REPLACE
:
20943 SET_NAME (rule
, rule_buf
[rule_pos
]);
20944 SET_P0 (rule
, rule_buf
[rule_pos
]);
20945 SET_P1 (rule
, rule_buf
[rule_pos
]);
20948 case RULE_OP_MANGLE_PURGECHAR
:
20952 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20956 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20957 SET_NAME (rule
, rule_buf
[rule_pos
]);
20958 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20961 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20962 SET_NAME (rule
, rule_buf
[rule_pos
]);
20963 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20966 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20967 SET_NAME (rule
, rule_buf
[rule_pos
]);
20970 case RULE_OP_MANGLE_SWITCH_FIRST
:
20971 SET_NAME (rule
, rule_buf
[rule_pos
]);
20974 case RULE_OP_MANGLE_SWITCH_LAST
:
20975 SET_NAME (rule
, rule_buf
[rule_pos
]);
20978 case RULE_OP_MANGLE_SWITCH_AT
:
20979 SET_NAME (rule
, rule_buf
[rule_pos
]);
20980 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20981 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20984 case RULE_OP_MANGLE_CHR_SHIFTL
:
20985 SET_NAME (rule
, rule_buf
[rule_pos
]);
20986 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20989 case RULE_OP_MANGLE_CHR_SHIFTR
:
20990 SET_NAME (rule
, rule_buf
[rule_pos
]);
20991 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20994 case RULE_OP_MANGLE_CHR_INCR
:
20995 SET_NAME (rule
, rule_buf
[rule_pos
]);
20996 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20999 case RULE_OP_MANGLE_CHR_DECR
:
21000 SET_NAME (rule
, rule_buf
[rule_pos
]);
21001 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21004 case RULE_OP_MANGLE_REPLACE_NP1
:
21005 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21009 case RULE_OP_MANGLE_REPLACE_NM1
:
21010 SET_NAME (rule
, rule_buf
[rule_pos
]);
21011 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21014 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21015 SET_NAME (rule
, rule_buf
[rule_pos
]);
21016 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21019 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21020 SET_NAME (rule
, rule_buf
[rule_pos
]);
21021 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21024 case RULE_OP_MANGLE_TITLE
:
21025 SET_NAME (rule
, rule_buf
[rule_pos
]);
21034 if (rule_pos
< rule_len
) return (-1);
21039 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21043 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21047 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21051 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21055 case RULE_OP_MANGLE_NOOP
:
21056 rule_buf
[rule_pos
] = rule_cmd
;
21059 case RULE_OP_MANGLE_LREST
:
21060 rule_buf
[rule_pos
] = rule_cmd
;
21063 case RULE_OP_MANGLE_UREST
:
21064 rule_buf
[rule_pos
] = rule_cmd
;
21067 case RULE_OP_MANGLE_LREST_UFIRST
:
21068 rule_buf
[rule_pos
] = rule_cmd
;
21071 case RULE_OP_MANGLE_UREST_LFIRST
:
21072 rule_buf
[rule_pos
] = rule_cmd
;
21075 case RULE_OP_MANGLE_TREST
:
21076 rule_buf
[rule_pos
] = rule_cmd
;
21079 case RULE_OP_MANGLE_TOGGLE_AT
:
21080 rule_buf
[rule_pos
] = rule_cmd
;
21081 GET_P0_CONV (rule
);
21084 case RULE_OP_MANGLE_REVERSE
:
21085 rule_buf
[rule_pos
] = rule_cmd
;
21088 case RULE_OP_MANGLE_DUPEWORD
:
21089 rule_buf
[rule_pos
] = rule_cmd
;
21092 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21093 rule_buf
[rule_pos
] = rule_cmd
;
21094 GET_P0_CONV (rule
);
21097 case RULE_OP_MANGLE_REFLECT
:
21098 rule_buf
[rule_pos
] = rule_cmd
;
21101 case RULE_OP_MANGLE_ROTATE_LEFT
:
21102 rule_buf
[rule_pos
] = rule_cmd
;
21105 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21106 rule_buf
[rule_pos
] = rule_cmd
;
21109 case RULE_OP_MANGLE_APPEND
:
21110 rule_buf
[rule_pos
] = rule_cmd
;
21114 case RULE_OP_MANGLE_PREPEND
:
21115 rule_buf
[rule_pos
] = rule_cmd
;
21119 case RULE_OP_MANGLE_DELETE_FIRST
:
21120 rule_buf
[rule_pos
] = rule_cmd
;
21123 case RULE_OP_MANGLE_DELETE_LAST
:
21124 rule_buf
[rule_pos
] = rule_cmd
;
21127 case RULE_OP_MANGLE_DELETE_AT
:
21128 rule_buf
[rule_pos
] = rule_cmd
;
21129 GET_P0_CONV (rule
);
21132 case RULE_OP_MANGLE_EXTRACT
:
21133 rule_buf
[rule_pos
] = rule_cmd
;
21134 GET_P0_CONV (rule
);
21135 GET_P1_CONV (rule
);
21138 case RULE_OP_MANGLE_OMIT
:
21139 rule_buf
[rule_pos
] = rule_cmd
;
21140 GET_P0_CONV (rule
);
21141 GET_P1_CONV (rule
);
21144 case RULE_OP_MANGLE_INSERT
:
21145 rule_buf
[rule_pos
] = rule_cmd
;
21146 GET_P0_CONV (rule
);
21150 case RULE_OP_MANGLE_OVERSTRIKE
:
21151 rule_buf
[rule_pos
] = rule_cmd
;
21152 GET_P0_CONV (rule
);
21156 case RULE_OP_MANGLE_TRUNCATE_AT
:
21157 rule_buf
[rule_pos
] = rule_cmd
;
21158 GET_P0_CONV (rule
);
21161 case RULE_OP_MANGLE_REPLACE
:
21162 rule_buf
[rule_pos
] = rule_cmd
;
21167 case RULE_OP_MANGLE_PURGECHAR
:
21171 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21175 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21176 rule_buf
[rule_pos
] = rule_cmd
;
21177 GET_P0_CONV (rule
);
21180 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21181 rule_buf
[rule_pos
] = rule_cmd
;
21182 GET_P0_CONV (rule
);
21185 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21186 rule_buf
[rule_pos
] = rule_cmd
;
21189 case RULE_OP_MANGLE_SWITCH_FIRST
:
21190 rule_buf
[rule_pos
] = rule_cmd
;
21193 case RULE_OP_MANGLE_SWITCH_LAST
:
21194 rule_buf
[rule_pos
] = rule_cmd
;
21197 case RULE_OP_MANGLE_SWITCH_AT
:
21198 rule_buf
[rule_pos
] = rule_cmd
;
21199 GET_P0_CONV (rule
);
21200 GET_P1_CONV (rule
);
21203 case RULE_OP_MANGLE_CHR_SHIFTL
:
21204 rule_buf
[rule_pos
] = rule_cmd
;
21205 GET_P0_CONV (rule
);
21208 case RULE_OP_MANGLE_CHR_SHIFTR
:
21209 rule_buf
[rule_pos
] = rule_cmd
;
21210 GET_P0_CONV (rule
);
21213 case RULE_OP_MANGLE_CHR_INCR
:
21214 rule_buf
[rule_pos
] = rule_cmd
;
21215 GET_P0_CONV (rule
);
21218 case RULE_OP_MANGLE_CHR_DECR
:
21219 rule_buf
[rule_pos
] = rule_cmd
;
21220 GET_P0_CONV (rule
);
21223 case RULE_OP_MANGLE_REPLACE_NP1
:
21224 rule_buf
[rule_pos
] = rule_cmd
;
21225 GET_P0_CONV (rule
);
21228 case RULE_OP_MANGLE_REPLACE_NM1
:
21229 rule_buf
[rule_pos
] = rule_cmd
;
21230 GET_P0_CONV (rule
);
21233 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21234 rule_buf
[rule_pos
] = rule_cmd
;
21235 GET_P0_CONV (rule
);
21238 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21239 rule_buf
[rule_pos
] = rule_cmd
;
21240 GET_P0_CONV (rule
);
21243 case RULE_OP_MANGLE_TITLE
:
21244 rule_buf
[rule_pos
] = rule_cmd
;
21248 return rule_pos
- 1;
21266 * CPU rules : this is from hashcat sources, cpu based rules
21269 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21270 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21272 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21273 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21274 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21276 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21277 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21278 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21280 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21284 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21289 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21293 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21298 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21302 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21307 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21312 for (l
= 0; l
< arr_len
; l
++)
21314 r
= arr_len
- 1 - l
;
21318 MANGLE_SWITCH (arr
, l
, r
);
21324 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21326 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21328 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21330 return (arr_len
* 2);
21333 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21335 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21337 int orig_len
= arr_len
;
21341 for (i
= 0; i
< times
; i
++)
21343 memcpy (&arr
[arr_len
], arr
, orig_len
);
21345 arr_len
+= orig_len
;
21351 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21353 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21355 mangle_double (arr
, arr_len
);
21357 mangle_reverse (arr
+ arr_len
, arr_len
);
21359 return (arr_len
* 2);
21362 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21367 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21369 MANGLE_SWITCH (arr
, l
, r
);
21375 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21380 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21382 MANGLE_SWITCH (arr
, l
, r
);
21388 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21390 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21394 return (arr_len
+ 1);
21397 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21399 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21403 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21405 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21410 return (arr_len
+ 1);
21413 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21415 if (upos
>= arr_len
) return (arr_len
);
21419 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21421 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21424 return (arr_len
- 1);
21427 int mangle_extract (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
= 0; arr_pos
< ulen
; arr_pos
++)
21437 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21443 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21445 if (upos
>= arr_len
) return (arr_len
);
21447 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21451 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21453 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21456 return (arr_len
- ulen
);
21459 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21461 if (upos
>= arr_len
) return (arr_len
);
21463 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21467 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21469 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21474 return (arr_len
+ 1);
21477 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
)
21479 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21481 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21483 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21485 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21487 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21489 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21491 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21493 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21495 return (arr_len
+ arr2_cpy
);
21498 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21500 if (upos
>= arr_len
) return (arr_len
);
21507 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21509 if (upos
>= arr_len
) return (arr_len
);
21511 memset (arr
+ upos
, 0, arr_len
- upos
);
21516 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21520 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21522 if (arr
[arr_pos
] != oldc
) continue;
21524 arr
[arr_pos
] = newc
;
21530 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21536 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21538 if (arr
[arr_pos
] == c
) continue;
21540 arr
[ret_len
] = arr
[arr_pos
];
21548 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21550 if (ulen
> arr_len
) return (arr_len
);
21552 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21554 char cs
[100] = { 0 };
21556 memcpy (cs
, arr
, ulen
);
21560 for (i
= 0; i
< ulen
; i
++)
21564 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21570 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21572 if (ulen
> arr_len
) return (arr_len
);
21574 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21576 int upos
= arr_len
- ulen
;
21580 for (i
= 0; i
< ulen
; i
++)
21582 char c
= arr
[upos
+ i
];
21584 arr_len
= mangle_append (arr
, arr_len
, c
);
21590 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21592 if ( arr_len
== 0) return (arr_len
);
21593 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21595 char c
= arr
[upos
];
21599 for (i
= 0; i
< ulen
; i
++)
21601 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21607 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21609 if ( arr_len
== 0) return (arr_len
);
21610 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21614 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21616 int new_pos
= arr_pos
* 2;
21618 arr
[new_pos
] = arr
[arr_pos
];
21620 arr
[new_pos
+ 1] = arr
[arr_pos
];
21623 return (arr_len
* 2);
21626 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21628 if (upos
>= arr_len
) return (arr_len
);
21629 if (upos2
>= arr_len
) return (arr_len
);
21631 MANGLE_SWITCH (arr
, upos
, upos2
);
21636 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21638 MANGLE_SWITCH (arr
, upos
, upos2
);
21643 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21645 if (upos
>= arr_len
) return (arr_len
);
21652 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21654 if (upos
>= arr_len
) return (arr_len
);
21661 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21663 if (upos
>= arr_len
) return (arr_len
);
21670 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21672 if (upos
>= arr_len
) return (arr_len
);
21679 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21681 int upper_next
= 1;
21685 for (pos
= 0; pos
< arr_len
; pos
++)
21687 if (arr
[pos
] == ' ')
21698 MANGLE_UPPER_AT (arr
, pos
);
21702 MANGLE_LOWER_AT (arr
, pos
);
21709 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21711 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21717 for (j
= 0; j
< rp_gen_num
; j
++)
21724 switch ((char) get_random_num (0, 9))
21727 r
= get_random_num (0, sizeof (grp_op_nop
));
21728 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21732 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21733 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21734 p1
= get_random_num (0, sizeof (grp_pos
));
21735 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21739 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21740 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21741 p1
= get_random_num (1, 6);
21742 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21746 r
= get_random_num (0, sizeof (grp_op_chr
));
21747 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21748 p1
= get_random_num (0x20, 0x7e);
21749 rule_buf
[rule_pos
++] = (char) p1
;
21753 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21754 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21755 p1
= get_random_num (0x20, 0x7e);
21756 rule_buf
[rule_pos
++] = (char) p1
;
21757 p2
= get_random_num (0x20, 0x7e);
21759 p2
= get_random_num (0x20, 0x7e);
21760 rule_buf
[rule_pos
++] = (char) p2
;
21764 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21765 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21766 p1
= get_random_num (0, sizeof (grp_pos
));
21767 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21768 p2
= get_random_num (0x20, 0x7e);
21769 rule_buf
[rule_pos
++] = (char) p2
;
21773 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21774 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21775 p1
= get_random_num (0, sizeof (grp_pos
));
21776 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21777 p2
= get_random_num (0, sizeof (grp_pos
));
21779 p2
= get_random_num (0, sizeof (grp_pos
));
21780 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21784 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21785 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21786 p1
= get_random_num (0, sizeof (grp_pos
));
21787 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21788 p2
= get_random_num (1, sizeof (grp_pos
));
21790 p2
= get_random_num (1, sizeof (grp_pos
));
21791 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21795 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21796 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21797 p1
= get_random_num (0, sizeof (grp_pos
));
21798 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21799 p2
= get_random_num (1, sizeof (grp_pos
));
21800 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21801 p3
= get_random_num (0, sizeof (grp_pos
));
21802 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21810 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21812 char mem
[BLOCK_SIZE
] = { 0 };
21814 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21816 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21818 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21820 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21822 int out_len
= in_len
;
21823 int mem_len
= in_len
;
21825 memcpy (out
, in
, out_len
);
21829 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21834 switch (rule
[rule_pos
])
21839 case RULE_OP_MANGLE_NOOP
:
21842 case RULE_OP_MANGLE_LREST
:
21843 out_len
= mangle_lrest (out
, out_len
);
21846 case RULE_OP_MANGLE_UREST
:
21847 out_len
= mangle_urest (out
, out_len
);
21850 case RULE_OP_MANGLE_LREST_UFIRST
:
21851 out_len
= mangle_lrest (out
, out_len
);
21852 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21855 case RULE_OP_MANGLE_UREST_LFIRST
:
21856 out_len
= mangle_urest (out
, out_len
);
21857 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21860 case RULE_OP_MANGLE_TREST
:
21861 out_len
= mangle_trest (out
, out_len
);
21864 case RULE_OP_MANGLE_TOGGLE_AT
:
21865 NEXT_RULEPOS (rule_pos
);
21866 NEXT_RPTOI (rule
, rule_pos
, upos
);
21867 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21870 case RULE_OP_MANGLE_REVERSE
:
21871 out_len
= mangle_reverse (out
, out_len
);
21874 case RULE_OP_MANGLE_DUPEWORD
:
21875 out_len
= mangle_double (out
, out_len
);
21878 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21879 NEXT_RULEPOS (rule_pos
);
21880 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21881 out_len
= mangle_double_times (out
, out_len
, ulen
);
21884 case RULE_OP_MANGLE_REFLECT
:
21885 out_len
= mangle_reflect (out
, out_len
);
21888 case RULE_OP_MANGLE_ROTATE_LEFT
:
21889 mangle_rotate_left (out
, out_len
);
21892 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21893 mangle_rotate_right (out
, out_len
);
21896 case RULE_OP_MANGLE_APPEND
:
21897 NEXT_RULEPOS (rule_pos
);
21898 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21901 case RULE_OP_MANGLE_PREPEND
:
21902 NEXT_RULEPOS (rule_pos
);
21903 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21906 case RULE_OP_MANGLE_DELETE_FIRST
:
21907 out_len
= mangle_delete_at (out
, out_len
, 0);
21910 case RULE_OP_MANGLE_DELETE_LAST
:
21911 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21914 case RULE_OP_MANGLE_DELETE_AT
:
21915 NEXT_RULEPOS (rule_pos
);
21916 NEXT_RPTOI (rule
, rule_pos
, upos
);
21917 out_len
= mangle_delete_at (out
, out_len
, upos
);
21920 case RULE_OP_MANGLE_EXTRACT
:
21921 NEXT_RULEPOS (rule_pos
);
21922 NEXT_RPTOI (rule
, rule_pos
, upos
);
21923 NEXT_RULEPOS (rule_pos
);
21924 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21925 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21928 case RULE_OP_MANGLE_OMIT
:
21929 NEXT_RULEPOS (rule_pos
);
21930 NEXT_RPTOI (rule
, rule_pos
, upos
);
21931 NEXT_RULEPOS (rule_pos
);
21932 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21933 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21936 case RULE_OP_MANGLE_INSERT
:
21937 NEXT_RULEPOS (rule_pos
);
21938 NEXT_RPTOI (rule
, rule_pos
, upos
);
21939 NEXT_RULEPOS (rule_pos
);
21940 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21943 case RULE_OP_MANGLE_OVERSTRIKE
:
21944 NEXT_RULEPOS (rule_pos
);
21945 NEXT_RPTOI (rule
, rule_pos
, upos
);
21946 NEXT_RULEPOS (rule_pos
);
21947 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21950 case RULE_OP_MANGLE_TRUNCATE_AT
:
21951 NEXT_RULEPOS (rule_pos
);
21952 NEXT_RPTOI (rule
, rule_pos
, upos
);
21953 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21956 case RULE_OP_MANGLE_REPLACE
:
21957 NEXT_RULEPOS (rule_pos
);
21958 NEXT_RULEPOS (rule_pos
);
21959 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21962 case RULE_OP_MANGLE_PURGECHAR
:
21963 NEXT_RULEPOS (rule_pos
);
21964 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21967 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21971 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21972 NEXT_RULEPOS (rule_pos
);
21973 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21974 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21977 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21978 NEXT_RULEPOS (rule_pos
);
21979 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21980 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21983 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21984 out_len
= mangle_dupechar (out
, out_len
);
21987 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21988 NEXT_RULEPOS (rule_pos
);
21989 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21990 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21993 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21994 NEXT_RULEPOS (rule_pos
);
21995 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21996 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21999 case RULE_OP_MANGLE_SWITCH_FIRST
:
22000 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22003 case RULE_OP_MANGLE_SWITCH_LAST
:
22004 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22007 case RULE_OP_MANGLE_SWITCH_AT
:
22008 NEXT_RULEPOS (rule_pos
);
22009 NEXT_RPTOI (rule
, rule_pos
, upos
);
22010 NEXT_RULEPOS (rule_pos
);
22011 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22012 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22015 case RULE_OP_MANGLE_CHR_SHIFTL
:
22016 NEXT_RULEPOS (rule_pos
);
22017 NEXT_RPTOI (rule
, rule_pos
, upos
);
22018 mangle_chr_shiftl (out
, out_len
, upos
);
22021 case RULE_OP_MANGLE_CHR_SHIFTR
:
22022 NEXT_RULEPOS (rule_pos
);
22023 NEXT_RPTOI (rule
, rule_pos
, upos
);
22024 mangle_chr_shiftr (out
, out_len
, upos
);
22027 case RULE_OP_MANGLE_CHR_INCR
:
22028 NEXT_RULEPOS (rule_pos
);
22029 NEXT_RPTOI (rule
, rule_pos
, upos
);
22030 mangle_chr_incr (out
, out_len
, upos
);
22033 case RULE_OP_MANGLE_CHR_DECR
:
22034 NEXT_RULEPOS (rule_pos
);
22035 NEXT_RPTOI (rule
, rule_pos
, upos
);
22036 mangle_chr_decr (out
, out_len
, upos
);
22039 case RULE_OP_MANGLE_REPLACE_NP1
:
22040 NEXT_RULEPOS (rule_pos
);
22041 NEXT_RPTOI (rule
, rule_pos
, upos
);
22042 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22045 case RULE_OP_MANGLE_REPLACE_NM1
:
22046 NEXT_RULEPOS (rule_pos
);
22047 NEXT_RPTOI (rule
, rule_pos
, upos
);
22048 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22051 case RULE_OP_MANGLE_TITLE
:
22052 out_len
= mangle_title (out
, out_len
);
22055 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22056 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22057 NEXT_RULEPOS (rule_pos
);
22058 NEXT_RPTOI (rule
, rule_pos
, upos
);
22059 NEXT_RULEPOS (rule_pos
);
22060 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22061 NEXT_RULEPOS (rule_pos
);
22062 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22063 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22066 case RULE_OP_MANGLE_APPEND_MEMORY
:
22067 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22068 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22069 memcpy (out
+ out_len
, mem
, mem_len
);
22070 out_len
+= mem_len
;
22073 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22074 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22075 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22076 memcpy (mem
+ mem_len
, out
, out_len
);
22077 out_len
+= mem_len
;
22078 memcpy (out
, mem
, out_len
);
22081 case RULE_OP_MEMORIZE_WORD
:
22082 memcpy (mem
, out
, out_len
);
22086 case RULE_OP_REJECT_LESS
:
22087 NEXT_RULEPOS (rule_pos
);
22088 NEXT_RPTOI (rule
, rule_pos
, upos
);
22089 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22092 case RULE_OP_REJECT_GREATER
:
22093 NEXT_RULEPOS (rule_pos
);
22094 NEXT_RPTOI (rule
, rule_pos
, upos
);
22095 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22098 case RULE_OP_REJECT_CONTAIN
:
22099 NEXT_RULEPOS (rule_pos
);
22100 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22103 case RULE_OP_REJECT_NOT_CONTAIN
:
22104 NEXT_RULEPOS (rule_pos
);
22105 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22108 case RULE_OP_REJECT_EQUAL_FIRST
:
22109 NEXT_RULEPOS (rule_pos
);
22110 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22113 case RULE_OP_REJECT_EQUAL_LAST
:
22114 NEXT_RULEPOS (rule_pos
);
22115 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22118 case RULE_OP_REJECT_EQUAL_AT
:
22119 NEXT_RULEPOS (rule_pos
);
22120 NEXT_RPTOI (rule
, rule_pos
, upos
);
22121 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22122 NEXT_RULEPOS (rule_pos
);
22123 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22126 case RULE_OP_REJECT_CONTAINS
:
22127 NEXT_RULEPOS (rule_pos
);
22128 NEXT_RPTOI (rule
, rule_pos
, upos
);
22129 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22130 NEXT_RULEPOS (rule_pos
);
22131 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22132 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22135 case RULE_OP_REJECT_MEMORY
:
22136 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22140 return (RULE_RC_SYNTAX_ERROR
);
22145 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);