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
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_temperature_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3092 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3094 #if defined(LINUX) && defined(HAVE_NVML)
3095 int temperature
= 0;
3097 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3102 #if defined(WIN) && defined(HAVE_NVAPI)
3103 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3105 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3106 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3107 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3108 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3110 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3112 return pThermalSettings
.sensor
[0].currentTemp
;
3113 #endif // WIN && HAVE_NVAPI
3115 #endif // HAVE_NVML || HAVE_NVAPI
3120 int hm_get_fanspeed_with_device_id (const uint device_id
)
3122 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3123 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3125 if (data
.hm_device
[device_id
].fan_supported
== 1)
3128 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLFanSpeedValue lpFanSpeedValue
;
3136 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3138 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3139 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3140 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3142 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3144 return lpFanSpeedValue
.iFanSpeed
;
3146 else // od_version == 6
3148 ADLOD6FanSpeedInfo faninfo
;
3150 memset (&faninfo
, 0, sizeof (faninfo
));
3152 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3154 return faninfo
.iFanSpeedPercent
;
3160 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3161 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3163 #if defined(LINUX) && defined(HAVE_NVML)
3166 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3171 #if defined(WIN) && defined(HAVE_NVAPI)
3173 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3175 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3177 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3179 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3182 #endif // HAVE_NVML || HAVE_NVAPI
3188 int hm_get_utilization_with_device_id (const uint device_id
)
3190 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3193 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3197 ADLPMActivity PMActivity
;
3199 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3201 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3203 return PMActivity
.iActivityPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3212 nvmlUtilization_t utilization
;
3214 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3216 return utilization
.gpu
;
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3222 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3224 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3226 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3237 if (data
.hm_device
[device_id
].fan_supported
== 1)
3241 if (data
.hm_device
[device_id
].od_version
== 5)
3243 ADLFanSpeedValue lpFanSpeedValue
;
3245 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3247 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3248 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3249 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3250 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3252 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3256 else // od_version == 6
3258 ADLOD6FanSpeedValue fan_speed_value
;
3260 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3262 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3263 fan_speed_value
.iFanSpeed
= fanspeed
;
3265 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3276 // helper function for status display
3278 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3280 #define VALUE_NOT_AVAILABLE "N/A"
3284 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3288 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3291 #endif // HAVE_HWMON
3297 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3299 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3301 if (css_cnt
> SP_PW_MAX
)
3303 log_error ("ERROR: mask length is too long");
3308 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3310 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3312 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3313 uint cs_len
= css
[css_pos
].cs_len
;
3315 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3317 uint c
= cs_buf
[cs_pos
] & 0xff;
3324 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3326 cs_t
*cs
= &css
[css_cnt
];
3328 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3330 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3334 for (i
= 0; i
< cs
->cs_len
; i
++)
3336 const uint u
= cs
->cs_buf
[i
];
3341 for (i
= 0; i
< in_len
; i
++)
3343 uint u
= in_buf
[i
] & 0xff;
3345 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3347 if (css_uniq
[u
] == 1) continue;
3351 cs
->cs_buf
[cs
->cs_len
] = u
;
3359 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3363 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3365 uint p0
= in_buf
[in_pos
] & 0xff;
3367 if (interpret
== 1 && p0
== '?')
3371 if (in_pos
== in_len
) break;
3373 uint p1
= in_buf
[in_pos
] & 0xff;
3377 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3379 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3381 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3383 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3385 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3387 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3389 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3390 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3403 default: log_error ("Syntax error: %s", in_buf
);
3409 if (data
.hex_charset
)
3413 if (in_pos
== in_len
)
3415 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3420 uint p1
= in_buf
[in_pos
] & 0xff;
3422 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3424 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3431 chr
= hex_convert (p1
) << 0;
3432 chr
|= hex_convert (p0
) << 4;
3434 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3440 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3446 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3450 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3452 sum
*= css
[css_pos
].cs_len
;
3458 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3460 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3465 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3467 char p0
= mask_buf
[mask_pos
];
3473 if (mask_pos
== mask_len
) break;
3475 char p1
= mask_buf
[mask_pos
];
3481 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3483 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3485 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3487 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3489 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3491 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3493 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3494 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3496 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3499 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3502 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3505 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3507 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3513 if (data
.hex_charset
)
3517 // if there is no 2nd hex character, show an error:
3519 if (mask_pos
== mask_len
)
3521 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3526 char p1
= mask_buf
[mask_pos
];
3528 // if they are not valid hex character, show an error:
3530 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3532 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3539 chr
|= hex_convert (p1
) << 0;
3540 chr
|= hex_convert (p0
) << 4;
3542 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3548 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3555 log_error ("ERROR: invalid mask length (0)");
3565 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3567 for (int i
= 0; i
< css_cnt
; i
++)
3569 uint len
= css
[i
].cs_len
;
3570 u64 next
= val
/ len
;
3571 uint pos
= val
% len
;
3572 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3577 void mp_cut_at (char *mask
, uint max
)
3581 uint mask_len
= strlen (mask
);
3583 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3585 if (mask
[i
] == '?') i
++;
3591 void mp_setup_sys (cs_t
*mp_sys
)
3595 uint donec
[CHARSIZ
] = { 0 };
3597 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3598 mp_sys
[0].cs_buf
[pos
++] = chr
;
3599 mp_sys
[0].cs_len
= pos
; }
3601 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3602 mp_sys
[1].cs_buf
[pos
++] = chr
;
3603 mp_sys
[1].cs_len
= pos
; }
3605 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3606 mp_sys
[2].cs_buf
[pos
++] = chr
;
3607 mp_sys
[2].cs_len
= pos
; }
3609 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3610 mp_sys
[3].cs_buf
[pos
++] = chr
;
3611 mp_sys
[3].cs_len
= pos
; }
3613 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3614 mp_sys
[4].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3617 mp_sys
[5].cs_len
= pos
; }
3620 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3622 FILE *fp
= fopen (buf
, "rb");
3624 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3626 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3630 char mp_file
[1024] = { 0 };
3632 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3636 len
= in_superchop (mp_file
);
3640 log_info ("WARNING: charset file corrupted");
3642 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3646 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3651 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3653 mp_usr
[index
].cs_len
= 0;
3655 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3658 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3660 char *new_mask_buf
= (char *) mymalloc (256);
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 if (css_pos
== len
) break;
3670 char p0
= mask_buf
[mask_pos
];
3672 new_mask_buf
[mask_pos
] = p0
;
3678 if (mask_pos
== mask_len
) break;
3680 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3684 if (data
.hex_charset
)
3688 if (mask_pos
== mask_len
)
3690 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3695 char p1
= mask_buf
[mask_pos
];
3697 // if they are not valid hex character, show an error:
3699 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3701 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3706 new_mask_buf
[mask_pos
] = p1
;
3711 if (css_pos
== len
) return (new_mask_buf
);
3713 myfree (new_mask_buf
);
3722 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3728 for (i
= start
; i
< stop
; i
++)
3730 sum
*= root_css_buf
[i
].cs_len
;
3736 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3740 cs_t
*cs
= &root_css_buf
[start
];
3744 for (i
= start
; i
< stop
; i
++)
3746 const u64 m
= v
% cs
->cs_len
;
3747 const u64 d
= v
/ cs
->cs_len
;
3751 const uint k
= cs
->cs_buf
[m
];
3753 pw_buf
[i
- start
] = (char) k
;
3755 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3759 int sp_comp_val (const void *p1
, const void *p2
)
3761 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3762 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3764 return b2
->val
- b1
->val
;
3767 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
)
3774 * Initialize hcstats
3777 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3779 u64
*root_stats_ptr
= root_stats_buf
;
3781 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3783 for (i
= 0; i
< SP_PW_MAX
; i
++)
3785 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3787 root_stats_ptr
+= CHARSIZ
;
3790 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3792 u64
*markov_stats_ptr
= markov_stats_buf
;
3794 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3796 for (i
= 0; i
< SP_PW_MAX
; i
++)
3798 for (j
= 0; j
< CHARSIZ
; j
++)
3800 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3802 markov_stats_ptr
+= CHARSIZ
;
3812 char hcstat_tmp
[256] = { 0 };
3814 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3816 hcstat
= hcstat_tmp
;
3819 FILE *fd
= fopen (hcstat
, "rb");
3823 log_error ("%s: %s", hcstat
, strerror (errno
));
3828 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3830 log_error ("%s: Could not load data", hcstat
);
3837 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3839 log_error ("%s: Could not load data", hcstat
);
3849 * Markov modifier of hcstat_table on user request
3854 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3855 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3860 /* Add all stats to first position */
3862 for (i
= 1; i
< SP_PW_MAX
; i
++)
3864 u64
*out
= root_stats_buf_by_pos
[0];
3865 u64
*in
= root_stats_buf_by_pos
[i
];
3867 for (j
= 0; j
< CHARSIZ
; j
++)
3873 for (i
= 1; i
< SP_PW_MAX
; i
++)
3875 u64
*out
= markov_stats_buf_by_key
[0][0];
3876 u64
*in
= markov_stats_buf_by_key
[i
][0];
3878 for (j
= 0; j
< CHARSIZ
; j
++)
3880 for (k
= 0; k
< CHARSIZ
; k
++)
3887 /* copy them to all pw_positions */
3889 for (i
= 1; i
< SP_PW_MAX
; i
++)
3891 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3894 for (i
= 1; i
< SP_PW_MAX
; i
++)
3896 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3904 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3906 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3908 for (i
= 0; i
< SP_PW_MAX
; i
++)
3910 root_table_buf_by_pos
[i
] = root_table_ptr
;
3912 root_table_ptr
+= CHARSIZ
;
3915 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3917 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3919 for (i
= 0; i
< SP_PW_MAX
; i
++)
3921 for (j
= 0; j
< CHARSIZ
; j
++)
3923 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3925 markov_table_ptr
+= CHARSIZ
;
3930 * Convert hcstat to tables
3933 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3935 uint key
= i
% CHARSIZ
;
3937 root_table_buf
[i
].key
= key
;
3938 root_table_buf
[i
].val
= root_stats_buf
[i
];
3941 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3943 uint key
= i
% CHARSIZ
;
3945 markov_table_buf
[i
].key
= key
;
3946 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3949 myfree (root_stats_buf
);
3950 myfree (markov_stats_buf
);
3956 for (i
= 0; i
< SP_PW_MAX
; i
++)
3958 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3961 for (i
= 0; i
< SP_PW_MAX
; i
++)
3963 for (j
= 0; j
< CHARSIZ
; j
++)
3965 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3970 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
])
3973 * Convert tables to css
3976 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3978 uint pw_pos
= i
/ CHARSIZ
;
3980 cs_t
*cs
= &root_css_buf
[pw_pos
];
3982 if (cs
->cs_len
== threshold
) continue;
3984 uint key
= root_table_buf
[i
].key
;
3986 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3988 cs
->cs_buf
[cs
->cs_len
] = key
;
3994 * Convert table to css
3997 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3999 uint c
= i
/ CHARSIZ
;
4001 cs_t
*cs
= &markov_css_buf
[c
];
4003 if (cs
->cs_len
== threshold
) continue;
4005 uint pw_pos
= c
/ CHARSIZ
;
4007 uint key
= markov_table_buf
[i
].key
;
4009 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4011 cs
->cs_buf
[cs
->cs_len
] = key
;
4017 for (uint i = 0; i < 8; i++)
4019 for (uint j = 0x20; j < 0x80; j++)
4021 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4023 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4025 for (uint k = 0; k < 10; k++)
4027 printf (" %u\n", ptr->cs_buf[k]);
4034 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4036 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4038 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4048 for (uint j
= 1; j
< CHARSIZ
; j
++)
4058 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4060 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4062 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4064 out
+= CHARSIZ
* CHARSIZ
;
4065 in
+= CHARSIZ
* CHARSIZ
;
4067 for (uint j
= 0; j
< CHARSIZ
; j
++)
4074 for (uint k
= 1; k
< CHARSIZ
; k
++)
4086 * mixed shared functions
4089 void dump_hex (const u8
*s
, const int sz
)
4091 for (int i
= 0; i
< sz
; i
++)
4093 log_info_nn ("%02x ", s
[i
]);
4099 void usage_mini_print (const char *progname
)
4101 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4104 void usage_big_print (const char *progname
)
4106 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4109 char *get_exec_path ()
4111 int exec_path_len
= 1024;
4113 char *exec_path
= (char *) mymalloc (exec_path_len
);
4117 char tmp
[32] = { 0 };
4119 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4121 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4125 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4129 uint size
= exec_path_len
;
4131 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4133 log_error("! executable path buffer too small\n");
4138 const int len
= strlen (exec_path
);
4141 #error Your Operating System is not supported or detected
4149 char *get_install_dir (const char *progname
)
4151 char *install_dir
= mystrdup (progname
);
4152 char *last_slash
= NULL
;
4154 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4158 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4164 install_dir
[0] = '.';
4168 return (install_dir
);
4171 char *get_profile_dir (const char *homedir
)
4173 #define DOT_HASHCAT ".hashcat"
4175 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4177 char *profile_dir
= (char *) mymalloc (len
+ 1);
4179 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4184 char *get_session_dir (const char *profile_dir
)
4186 #define SESSIONS_FOLDER "sessions"
4188 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4190 char *session_dir
= (char *) mymalloc (len
+ 1);
4192 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4197 uint
count_lines (FILE *fd
)
4201 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4207 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4209 if (nread
< 1) continue;
4213 for (i
= 0; i
< nread
; i
++)
4215 if (prev
== '\n') cnt
++;
4226 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4230 FILE *fd
= fopen (filename
, "rb");
4234 log_error ("%s: %s", filename
, strerror (errno
));
4239 #define MAX_KEY_SIZE (1024 * 1024)
4241 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4243 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4249 for (int fpos
= 0; fpos
< nread
; fpos
++)
4251 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4253 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4256 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4258 if (kpos
>= 64) kpos
= 0;
4265 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4269 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4270 if (CPU_ISSET(core
, cpu_set
)) break;
4272 thread_affinity_policy_data_t policy
= { core
};
4274 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4276 if (data
.quiet
== 0)
4278 if (rc
!= KERN_SUCCESS
)
4280 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4288 void set_cpu_affinity (char *cpu_affinity
)
4291 DWORD_PTR aff_mask
= 0;
4299 char *devices
= strdup (cpu_affinity
);
4301 char *next
= strtok (devices
, ",");
4305 uint cpu_id
= atoi (next
);
4320 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4326 aff_mask
|= 1 << (cpu_id
- 1);
4328 CPU_SET ((cpu_id
- 1), &cpuset
);
4331 } while ((next
= strtok (NULL
, ",")) != NULL
);
4337 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4338 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4340 pthread_t thread
= pthread_self ();
4341 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4345 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4347 char *element
, *end
;
4349 end
= (char *) base
+ nmemb
* size
;
4351 for (element
= (char *) base
; element
< end
; element
+= size
)
4352 if (!compar (element
, key
))
4358 int sort_by_u32 (const void *v1
, const void *v2
)
4360 const u32
*s1
= (const u32
*) v1
;
4361 const u32
*s2
= (const u32
*) v2
;
4366 int sort_by_salt (const void *v1
, const void *v2
)
4368 const salt_t
*s1
= (const salt_t
*) v1
;
4369 const salt_t
*s2
= (const salt_t
*) v2
;
4371 const int res1
= s1
->salt_len
- s2
->salt_len
;
4373 if (res1
!= 0) return (res1
);
4375 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4377 if (res2
!= 0) return (res2
);
4385 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4386 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4393 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4394 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4400 int sort_by_salt_buf (const void *v1
, const void *v2
)
4402 const pot_t
*p1
= (const pot_t
*) v1
;
4403 const pot_t
*p2
= (const pot_t
*) v2
;
4405 const hash_t
*h1
= &p1
->hash
;
4406 const hash_t
*h2
= &p2
->hash
;
4408 const salt_t
*s1
= h1
->salt
;
4409 const salt_t
*s2
= h2
->salt
;
4415 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4416 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4422 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4424 const hash_t
*h1
= (const hash_t
*) v1
;
4425 const hash_t
*h2
= (const hash_t
*) v2
;
4427 const salt_t
*s1
= h1
->salt
;
4428 const salt_t
*s2
= h2
->salt
;
4430 // testphase: this should work
4435 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4436 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4439 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4440 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4441 if (s1->salt_len > s2->salt_len) return ( 1);
4442 if (s1->salt_len < s2->salt_len) return (-1);
4444 uint n = s1->salt_len;
4448 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4449 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4456 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4458 const hash_t
*h1
= (const hash_t
*) v1
;
4459 const hash_t
*h2
= (const hash_t
*) v2
;
4461 const salt_t
*s1
= h1
->salt
;
4462 const salt_t
*s2
= h2
->salt
;
4464 // 16 - 2 (since last 2 uints contain the digest)
4469 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4470 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4476 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4478 const hash_t
*h1
= (const hash_t
*) v1
;
4479 const hash_t
*h2
= (const hash_t
*) v2
;
4481 const void *d1
= h1
->digest
;
4482 const void *d2
= h2
->digest
;
4484 return data
.sort_by_digest (d1
, d2
);
4487 int sort_by_hash (const void *v1
, const void *v2
)
4489 const hash_t
*h1
= (const hash_t
*) v1
;
4490 const hash_t
*h2
= (const hash_t
*) v2
;
4494 const salt_t
*s1
= h1
->salt
;
4495 const salt_t
*s2
= h2
->salt
;
4497 int res
= sort_by_salt (s1
, s2
);
4499 if (res
!= 0) return (res
);
4502 const void *d1
= h1
->digest
;
4503 const void *d2
= h2
->digest
;
4505 return data
.sort_by_digest (d1
, d2
);
4508 int sort_by_pot (const void *v1
, const void *v2
)
4510 const pot_t
*p1
= (const pot_t
*) v1
;
4511 const pot_t
*p2
= (const pot_t
*) v2
;
4513 const hash_t
*h1
= &p1
->hash
;
4514 const hash_t
*h2
= &p2
->hash
;
4516 return sort_by_hash (h1
, h2
);
4519 int sort_by_mtime (const void *p1
, const void *p2
)
4521 const char **f1
= (const char **) p1
;
4522 const char **f2
= (const char **) p2
;
4524 struct stat s1
; stat (*f1
, &s1
);
4525 struct stat s2
; stat (*f2
, &s2
);
4527 return s2
.st_mtime
- s1
.st_mtime
;
4530 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4532 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4533 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4535 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4538 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4540 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4541 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4543 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4546 int sort_by_stringptr (const void *p1
, const void *p2
)
4548 const char **s1
= (const char **) p1
;
4549 const char **s2
= (const char **) p2
;
4551 return strcmp (*s1
, *s2
);
4554 int sort_by_dictstat (const void *s1
, const void *s2
)
4556 dictstat_t
*d1
= (dictstat_t
*) s1
;
4557 dictstat_t
*d2
= (dictstat_t
*) s2
;
4560 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4562 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4565 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4568 int sort_by_bitmap (const void *p1
, const void *p2
)
4570 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4571 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4573 return b1
->collisions
- b2
->collisions
;
4576 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4578 const u32
*d1
= (const u32
*) v1
;
4579 const u32
*d2
= (const u32
*) v2
;
4585 if (d1
[n
] > d2
[n
]) return ( 1);
4586 if (d1
[n
] < d2
[n
]) return (-1);
4592 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4594 const u32
*d1
= (const u32
*) v1
;
4595 const u32
*d2
= (const u32
*) v2
;
4601 if (d1
[n
] > d2
[n
]) return ( 1);
4602 if (d1
[n
] < d2
[n
]) return (-1);
4608 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4610 const u32
*d1
= (const u32
*) v1
;
4611 const u32
*d2
= (const u32
*) v2
;
4617 if (d1
[n
] > d2
[n
]) return ( 1);
4618 if (d1
[n
] < d2
[n
]) return (-1);
4624 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4626 const u32
*d1
= (const u32
*) v1
;
4627 const u32
*d2
= (const u32
*) v2
;
4633 if (d1
[n
] > d2
[n
]) return ( 1);
4634 if (d1
[n
] < d2
[n
]) return (-1);
4640 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4642 const u32
*d1
= (const u32
*) v1
;
4643 const u32
*d2
= (const u32
*) v2
;
4649 if (d1
[n
] > d2
[n
]) return ( 1);
4650 if (d1
[n
] < d2
[n
]) return (-1);
4656 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4658 const u32
*d1
= (const u32
*) v1
;
4659 const u32
*d2
= (const u32
*) v2
;
4665 if (d1
[n
] > d2
[n
]) return ( 1);
4666 if (d1
[n
] < d2
[n
]) return (-1);
4672 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4674 const u32
*d1
= (const u32
*) v1
;
4675 const u32
*d2
= (const u32
*) v2
;
4681 if (d1
[n
] > d2
[n
]) return ( 1);
4682 if (d1
[n
] < d2
[n
]) return (-1);
4688 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4690 const u32
*d1
= (const u32
*) v1
;
4691 const u32
*d2
= (const u32
*) v2
;
4697 if (d1
[n
] > d2
[n
]) return ( 1);
4698 if (d1
[n
] < d2
[n
]) return (-1);
4704 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4706 const u64
*d1
= (const u64
*) v1
;
4707 const u64
*d2
= (const u64
*) v2
;
4713 if (d1
[n
] > d2
[n
]) return ( 1);
4714 if (d1
[n
] < d2
[n
]) return (-1);
4720 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4722 const u64
*d1
= (const u64
*) v1
;
4723 const u64
*d2
= (const u64
*) v2
;
4729 if (d1
[n
] > d2
[n
]) return ( 1);
4730 if (d1
[n
] < d2
[n
]) return (-1);
4736 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4738 const u64
*d1
= (const u64
*) v1
;
4739 const u64
*d2
= (const u64
*) v2
;
4745 if (d1
[n
] > d2
[n
]) return ( 1);
4746 if (d1
[n
] < d2
[n
]) return (-1);
4752 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4754 const u32
*d1
= (const u32
*) v1
;
4755 const u32
*d2
= (const u32
*) v2
;
4757 const uint dgst_pos0
= data
.dgst_pos0
;
4758 const uint dgst_pos1
= data
.dgst_pos1
;
4759 const uint dgst_pos2
= data
.dgst_pos2
;
4760 const uint dgst_pos3
= data
.dgst_pos3
;
4762 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4763 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4764 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4765 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4766 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4767 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4768 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4769 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4774 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4776 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4777 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4779 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4781 if (res1
!= 0) return (res1
);
4786 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4788 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4789 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4791 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4793 if (res1
!= 0) return (res1
);
4795 const int res2
= t1
->attack_mode
4798 if (res2
!= 0) return (res2
);
4800 const int res3
= t1
->hash_type
4803 if (res3
!= 0) return (res3
);
4808 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
)
4810 uint outfile_autohex
= data
.outfile_autohex
;
4812 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4814 FILE *debug_fp
= NULL
;
4816 if (debug_file
!= NULL
)
4818 debug_fp
= fopen (debug_file
, "ab");
4820 lock_file (debug_fp
);
4827 if (debug_fp
== NULL
)
4829 log_info ("WARNING: Could not open debug-file for writing");
4833 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4835 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4837 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4840 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4842 if (debug_mode
== 4)
4844 fputc (':', debug_fp
);
4846 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4849 fputc ('\n', debug_fp
);
4851 if (debug_file
!= NULL
) fclose (debug_fp
);
4855 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4857 int needs_hexify
= 0;
4859 if (outfile_autohex
== 1)
4861 for (uint i
= 0; i
< plain_len
; i
++)
4863 if (plain_ptr
[i
] < 0x20)
4870 if (plain_ptr
[i
] > 0x7f)
4879 if (needs_hexify
== 1)
4881 fprintf (fp
, "$HEX[");
4883 for (uint i
= 0; i
< plain_len
; i
++)
4885 fprintf (fp
, "%02x", plain_ptr
[i
]);
4892 fwrite (plain_ptr
, plain_len
, 1, fp
);
4896 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
)
4898 uint outfile_format
= data
.outfile_format
;
4900 char separator
= data
.separator
;
4902 if (outfile_format
& OUTFILE_FMT_HASH
)
4904 fprintf (out_fp
, "%s", out_buf
);
4906 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4908 fputc (separator
, out_fp
);
4911 else if (data
.username
)
4913 if (username
!= NULL
)
4915 for (uint i
= 0; i
< user_len
; i
++)
4917 fprintf (out_fp
, "%c", username
[i
]);
4920 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4922 fputc (separator
, out_fp
);
4927 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4929 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4931 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4933 fputc (separator
, out_fp
);
4937 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4939 for (uint i
= 0; i
< plain_len
; i
++)
4941 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4944 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4946 fputc (separator
, out_fp
);
4950 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4953 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4958 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4960 fprintf (out_fp
, "%llu", crackpos
);
4965 fputc ('\n', out_fp
);
4968 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
)
4972 pot_key
.hash
.salt
= hashes_buf
->salt
;
4973 pot_key
.hash
.digest
= hashes_buf
->digest
;
4975 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4981 input_buf
[input_len
] = 0;
4984 unsigned char *username
= NULL
;
4989 user_t
*user
= hashes_buf
->hash_info
->user
;
4993 username
= (unsigned char *) (user
->user_name
);
4995 user_len
= user
->user_len
;
4999 // do output the line
5000 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5004 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5005 #define LM_MASKED_PLAIN "[notfound]"
5007 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
)
5013 pot_left_key
.hash
.salt
= hash_left
->salt
;
5014 pot_left_key
.hash
.digest
= hash_left
->digest
;
5016 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5020 uint weak_hash_found
= 0;
5022 pot_t pot_right_key
;
5024 pot_right_key
.hash
.salt
= hash_right
->salt
;
5025 pot_right_key
.hash
.digest
= hash_right
->digest
;
5027 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5029 if (pot_right_ptr
== NULL
)
5031 // special case, if "weak hash"
5033 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5035 weak_hash_found
= 1;
5037 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5039 // in theory this is not needed, but we are paranoia:
5041 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5042 pot_right_ptr
->plain_len
= 0;
5046 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5048 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
5053 // at least one half was found:
5057 input_buf
[input_len
] = 0;
5061 unsigned char *username
= NULL
;
5066 user_t
*user
= hash_left
->hash_info
->user
;
5070 username
= (unsigned char *) (user
->user_name
);
5072 user_len
= user
->user_len
;
5076 // mask the part which was not found
5078 uint left_part_masked
= 0;
5079 uint right_part_masked
= 0;
5081 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5083 if (pot_left_ptr
== NULL
)
5085 left_part_masked
= 1;
5087 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5089 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5091 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5092 pot_left_ptr
->plain_len
= mask_plain_len
;
5095 if (pot_right_ptr
== NULL
)
5097 right_part_masked
= 1;
5099 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5101 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5103 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5104 pot_right_ptr
->plain_len
= mask_plain_len
;
5107 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5111 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5113 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5115 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5117 // do output the line
5119 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5121 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5123 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5124 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5127 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
)
5131 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5133 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5135 if (pot_ptr
== NULL
)
5139 input_buf
[input_len
] = 0;
5141 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5145 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
)
5151 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5153 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5157 pot_t pot_right_key
;
5159 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5161 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5163 uint weak_hash_found
= 0;
5165 if (pot_right_ptr
== NULL
)
5167 // special case, if "weak hash"
5169 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5171 weak_hash_found
= 1;
5173 // we just need that pot_right_ptr is not a NULL pointer
5175 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5179 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5181 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5186 // ... at least one part was not cracked
5190 input_buf
[input_len
] = 0;
5192 // only show the hash part which is still not cracked
5194 uint user_len
= input_len
- 32;
5196 char *hash_output
= (char *) mymalloc (33);
5198 memcpy (hash_output
, input_buf
, input_len
);
5200 if (pot_left_ptr
!= NULL
)
5202 // only show right part (because left part was already found)
5204 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5206 hash_output
[user_len
+ 16] = 0;
5209 if (pot_right_ptr
!= NULL
)
5211 // only show left part (because right part was already found)
5213 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5215 hash_output
[user_len
+ 16] = 0;
5218 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5220 myfree (hash_output
);
5222 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5225 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5227 uint opencl_platforms_filter
= 0;
5229 if (opencl_platforms
)
5231 char *platforms
= strdup (opencl_platforms
);
5233 char *next
= strtok (platforms
, ",");
5237 int platform
= atoi (next
);
5239 if (platform
< 1 || platform
> 32)
5241 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5246 opencl_platforms_filter
|= 1 << (platform
- 1);
5248 } while ((next
= strtok (NULL
, ",")) != NULL
);
5254 opencl_platforms_filter
= -1;
5257 return opencl_platforms_filter
;
5260 u32
setup_devices_filter (char *opencl_devices
)
5262 u32 devices_filter
= 0;
5266 char *devices
= strdup (opencl_devices
);
5268 char *next
= strtok (devices
, ",");
5272 int device_id
= atoi (next
);
5274 if (device_id
< 1 || device_id
> 32)
5276 log_error ("ERROR: invalid device_id %u specified", device_id
);
5281 devices_filter
|= 1 << (device_id
- 1);
5283 } while ((next
= strtok (NULL
, ",")) != NULL
);
5289 devices_filter
= -1;
5292 return devices_filter
;
5295 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5297 cl_device_type device_types_filter
= 0;
5299 if (opencl_device_types
)
5301 char *device_types
= strdup (opencl_device_types
);
5303 char *next
= strtok (device_types
, ",");
5307 int device_type
= atoi (next
);
5309 if (device_type
< 1 || device_type
> 3)
5311 log_error ("ERROR: invalid device_type %u specified", device_type
);
5316 device_types_filter
|= 1 << device_type
;
5318 } while ((next
= strtok (NULL
, ",")) != NULL
);
5320 free (device_types
);
5324 // Do not use CPU by default, this often reduces GPU performance because
5325 // the CPU is too busy to handle GPU synchronization
5327 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5330 return device_types_filter
;
5333 u32
get_random_num (const u32 min
, const u32 max
)
5335 if (min
== max
) return (min
);
5337 return ((rand () % (max
- min
)) + min
);
5340 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5342 u32 quotient
= dividend
/ divisor
;
5344 if (dividend
% divisor
) quotient
++;
5349 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5351 u64 quotient
= dividend
/ divisor
;
5353 if (dividend
% divisor
) quotient
++;
5358 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5360 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5361 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5363 if (tm
->tm_year
- 70)
5365 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5366 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5368 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5370 else if (tm
->tm_yday
)
5372 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5373 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5375 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5377 else if (tm
->tm_hour
)
5379 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5380 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5382 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5384 else if (tm
->tm_min
)
5386 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5387 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5389 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5393 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5395 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5399 void format_speed_display (float val
, char *buf
, size_t len
)
5410 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5421 /* generate output */
5425 snprintf (buf
, len
- 1, "%.0f ", val
);
5429 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5433 void lowercase (u8
*buf
, int len
)
5435 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5438 void uppercase (u8
*buf
, int len
)
5440 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5443 int fgetl (FILE *fp
, char *line_buf
)
5449 const int c
= fgetc (fp
);
5451 if (c
== EOF
) break;
5453 line_buf
[line_len
] = (char) c
;
5457 if (line_len
== HCBUFSIZ
) line_len
--;
5459 if (c
== '\n') break;
5462 if (line_len
== 0) return 0;
5464 if (line_buf
[line_len
- 1] == '\n')
5468 line_buf
[line_len
] = 0;
5471 if (line_len
== 0) return 0;
5473 if (line_buf
[line_len
- 1] == '\r')
5477 line_buf
[line_len
] = 0;
5483 int in_superchop (char *buf
)
5485 int len
= strlen (buf
);
5489 if (buf
[len
- 1] == '\n')
5496 if (buf
[len
- 1] == '\r')
5511 char **scan_directory (const char *path
)
5513 char *tmp_path
= mystrdup (path
);
5515 size_t tmp_path_len
= strlen (tmp_path
);
5517 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5519 tmp_path
[tmp_path_len
- 1] = 0;
5521 tmp_path_len
= strlen (tmp_path
);
5524 char **files
= NULL
;
5530 if ((d
= opendir (tmp_path
)) != NULL
)
5536 memset (&e
, 0, sizeof (e
));
5537 struct dirent
*de
= NULL
;
5539 if (readdir_r (d
, &e
, &de
) != 0)
5541 log_error ("ERROR: readdir_r() failed");
5546 if (de
== NULL
) break;
5550 while ((de
= readdir (d
)) != NULL
)
5553 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5555 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5557 char *path_file
= (char *) mymalloc (path_size
+ 1);
5559 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5561 path_file
[path_size
] = 0;
5565 if ((d_test
= opendir (path_file
)) != NULL
)
5573 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5577 files
[num_files
- 1] = path_file
;
5583 else if (errno
== ENOTDIR
)
5585 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5589 files
[num_files
- 1] = mystrdup (path
);
5592 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5596 files
[num_files
- 1] = NULL
;
5603 int count_dictionaries (char **dictionary_files
)
5605 if (dictionary_files
== NULL
) return 0;
5609 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5617 char *stroptitype (const uint opti_type
)
5621 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5622 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5623 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5624 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5625 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5626 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5627 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5628 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5629 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5630 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5631 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5632 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5633 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5634 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5635 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5636 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5637 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5638 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5639 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5645 char *strparser (const uint parser_status
)
5647 switch (parser_status
)
5649 case PARSER_OK
: return ((char *) PA_000
); break;
5650 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5651 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5652 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5653 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5654 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5655 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5656 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5657 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5658 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5659 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5660 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5661 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5662 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5663 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5664 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5665 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5668 return ((char *) PA_255
);
5671 char *strhashtype (const uint hash_mode
)
5675 case 0: return ((char *) HT_00000
); break;
5676 case 10: return ((char *) HT_00010
); break;
5677 case 11: return ((char *) HT_00011
); break;
5678 case 12: return ((char *) HT_00012
); break;
5679 case 20: return ((char *) HT_00020
); break;
5680 case 21: return ((char *) HT_00021
); break;
5681 case 22: return ((char *) HT_00022
); break;
5682 case 23: return ((char *) HT_00023
); break;
5683 case 30: return ((char *) HT_00030
); break;
5684 case 40: return ((char *) HT_00040
); break;
5685 case 50: return ((char *) HT_00050
); break;
5686 case 60: return ((char *) HT_00060
); break;
5687 case 100: return ((char *) HT_00100
); break;
5688 case 101: return ((char *) HT_00101
); break;
5689 case 110: return ((char *) HT_00110
); break;
5690 case 111: return ((char *) HT_00111
); break;
5691 case 112: return ((char *) HT_00112
); break;
5692 case 120: return ((char *) HT_00120
); break;
5693 case 121: return ((char *) HT_00121
); break;
5694 case 122: return ((char *) HT_00122
); break;
5695 case 124: return ((char *) HT_00124
); break;
5696 case 125: return ((char *) HT_00125
); break;
5697 case 130: return ((char *) HT_00130
); break;
5698 case 131: return ((char *) HT_00131
); break;
5699 case 132: return ((char *) HT_00132
); break;
5700 case 133: return ((char *) HT_00133
); break;
5701 case 140: return ((char *) HT_00140
); break;
5702 case 141: return ((char *) HT_00141
); break;
5703 case 150: return ((char *) HT_00150
); break;
5704 case 160: return ((char *) HT_00160
); break;
5705 case 190: return ((char *) HT_00190
); break;
5706 case 200: return ((char *) HT_00200
); break;
5707 case 300: return ((char *) HT_00300
); break;
5708 case 400: return ((char *) HT_00400
); break;
5709 case 500: return ((char *) HT_00500
); break;
5710 case 501: return ((char *) HT_00501
); break;
5711 case 900: return ((char *) HT_00900
); break;
5712 case 910: return ((char *) HT_00910
); break;
5713 case 1000: return ((char *) HT_01000
); break;
5714 case 1100: return ((char *) HT_01100
); break;
5715 case 1400: return ((char *) HT_01400
); break;
5716 case 1410: return ((char *) HT_01410
); break;
5717 case 1420: return ((char *) HT_01420
); break;
5718 case 1421: return ((char *) HT_01421
); break;
5719 case 1430: return ((char *) HT_01430
); break;
5720 case 1440: return ((char *) HT_01440
); break;
5721 case 1441: return ((char *) HT_01441
); break;
5722 case 1450: return ((char *) HT_01450
); break;
5723 case 1460: return ((char *) HT_01460
); break;
5724 case 1500: return ((char *) HT_01500
); break;
5725 case 1600: return ((char *) HT_01600
); break;
5726 case 1700: return ((char *) HT_01700
); break;
5727 case 1710: return ((char *) HT_01710
); break;
5728 case 1711: return ((char *) HT_01711
); break;
5729 case 1720: return ((char *) HT_01720
); break;
5730 case 1722: return ((char *) HT_01722
); break;
5731 case 1730: return ((char *) HT_01730
); break;
5732 case 1731: return ((char *) HT_01731
); break;
5733 case 1740: return ((char *) HT_01740
); break;
5734 case 1750: return ((char *) HT_01750
); break;
5735 case 1760: return ((char *) HT_01760
); break;
5736 case 1800: return ((char *) HT_01800
); break;
5737 case 2100: return ((char *) HT_02100
); break;
5738 case 2400: return ((char *) HT_02400
); break;
5739 case 2410: return ((char *) HT_02410
); break;
5740 case 2500: return ((char *) HT_02500
); break;
5741 case 2600: return ((char *) HT_02600
); break;
5742 case 2611: return ((char *) HT_02611
); break;
5743 case 2612: return ((char *) HT_02612
); break;
5744 case 2711: return ((char *) HT_02711
); break;
5745 case 2811: return ((char *) HT_02811
); break;
5746 case 3000: return ((char *) HT_03000
); break;
5747 case 3100: return ((char *) HT_03100
); break;
5748 case 3200: return ((char *) HT_03200
); break;
5749 case 3710: return ((char *) HT_03710
); break;
5750 case 3711: return ((char *) HT_03711
); break;
5751 case 3800: return ((char *) HT_03800
); break;
5752 case 4300: return ((char *) HT_04300
); break;
5753 case 4400: return ((char *) HT_04400
); break;
5754 case 4500: return ((char *) HT_04500
); break;
5755 case 4700: return ((char *) HT_04700
); break;
5756 case 4800: return ((char *) HT_04800
); break;
5757 case 4900: return ((char *) HT_04900
); break;
5758 case 5000: return ((char *) HT_05000
); break;
5759 case 5100: return ((char *) HT_05100
); break;
5760 case 5200: return ((char *) HT_05200
); break;
5761 case 5300: return ((char *) HT_05300
); break;
5762 case 5400: return ((char *) HT_05400
); break;
5763 case 5500: return ((char *) HT_05500
); break;
5764 case 5600: return ((char *) HT_05600
); break;
5765 case 5700: return ((char *) HT_05700
); break;
5766 case 5800: return ((char *) HT_05800
); break;
5767 case 6000: return ((char *) HT_06000
); break;
5768 case 6100: return ((char *) HT_06100
); break;
5769 case 6211: return ((char *) HT_06211
); break;
5770 case 6212: return ((char *) HT_06212
); break;
5771 case 6213: return ((char *) HT_06213
); break;
5772 case 6221: return ((char *) HT_06221
); break;
5773 case 6222: return ((char *) HT_06222
); break;
5774 case 6223: return ((char *) HT_06223
); break;
5775 case 6231: return ((char *) HT_06231
); break;
5776 case 6232: return ((char *) HT_06232
); break;
5777 case 6233: return ((char *) HT_06233
); break;
5778 case 6241: return ((char *) HT_06241
); break;
5779 case 6242: return ((char *) HT_06242
); break;
5780 case 6243: return ((char *) HT_06243
); break;
5781 case 6300: return ((char *) HT_06300
); break;
5782 case 6400: return ((char *) HT_06400
); break;
5783 case 6500: return ((char *) HT_06500
); break;
5784 case 6600: return ((char *) HT_06600
); break;
5785 case 6700: return ((char *) HT_06700
); break;
5786 case 6800: return ((char *) HT_06800
); break;
5787 case 6900: return ((char *) HT_06900
); break;
5788 case 7100: return ((char *) HT_07100
); break;
5789 case 7200: return ((char *) HT_07200
); break;
5790 case 7300: return ((char *) HT_07300
); break;
5791 case 7400: return ((char *) HT_07400
); break;
5792 case 7500: return ((char *) HT_07500
); break;
5793 case 7600: return ((char *) HT_07600
); break;
5794 case 7700: return ((char *) HT_07700
); break;
5795 case 7800: return ((char *) HT_07800
); break;
5796 case 7900: return ((char *) HT_07900
); break;
5797 case 8000: return ((char *) HT_08000
); break;
5798 case 8100: return ((char *) HT_08100
); break;
5799 case 8200: return ((char *) HT_08200
); break;
5800 case 8300: return ((char *) HT_08300
); break;
5801 case 8400: return ((char *) HT_08400
); break;
5802 case 8500: return ((char *) HT_08500
); break;
5803 case 8600: return ((char *) HT_08600
); break;
5804 case 8700: return ((char *) HT_08700
); break;
5805 case 8800: return ((char *) HT_08800
); break;
5806 case 8900: return ((char *) HT_08900
); break;
5807 case 9000: return ((char *) HT_09000
); break;
5808 case 9100: return ((char *) HT_09100
); break;
5809 case 9200: return ((char *) HT_09200
); break;
5810 case 9300: return ((char *) HT_09300
); break;
5811 case 9400: return ((char *) HT_09400
); break;
5812 case 9500: return ((char *) HT_09500
); break;
5813 case 9600: return ((char *) HT_09600
); break;
5814 case 9700: return ((char *) HT_09700
); break;
5815 case 9710: return ((char *) HT_09710
); break;
5816 case 9720: return ((char *) HT_09720
); break;
5817 case 9800: return ((char *) HT_09800
); break;
5818 case 9810: return ((char *) HT_09810
); break;
5819 case 9820: return ((char *) HT_09820
); break;
5820 case 9900: return ((char *) HT_09900
); break;
5821 case 10000: return ((char *) HT_10000
); break;
5822 case 10100: return ((char *) HT_10100
); break;
5823 case 10200: return ((char *) HT_10200
); break;
5824 case 10300: return ((char *) HT_10300
); break;
5825 case 10400: return ((char *) HT_10400
); break;
5826 case 10410: return ((char *) HT_10410
); break;
5827 case 10420: return ((char *) HT_10420
); break;
5828 case 10500: return ((char *) HT_10500
); break;
5829 case 10600: return ((char *) HT_10600
); break;
5830 case 10700: return ((char *) HT_10700
); break;
5831 case 10800: return ((char *) HT_10800
); break;
5832 case 10900: return ((char *) HT_10900
); break;
5833 case 11000: return ((char *) HT_11000
); break;
5834 case 11100: return ((char *) HT_11100
); break;
5835 case 11200: return ((char *) HT_11200
); break;
5836 case 11300: return ((char *) HT_11300
); break;
5837 case 11400: return ((char *) HT_11400
); break;
5838 case 11500: return ((char *) HT_11500
); break;
5839 case 11600: return ((char *) HT_11600
); break;
5840 case 11700: return ((char *) HT_11700
); break;
5841 case 11800: return ((char *) HT_11800
); break;
5842 case 11900: return ((char *) HT_11900
); break;
5843 case 12000: return ((char *) HT_12000
); break;
5844 case 12100: return ((char *) HT_12100
); break;
5845 case 12200: return ((char *) HT_12200
); break;
5846 case 12300: return ((char *) HT_12300
); break;
5847 case 12400: return ((char *) HT_12400
); break;
5848 case 12500: return ((char *) HT_12500
); break;
5849 case 12600: return ((char *) HT_12600
); break;
5850 case 12700: return ((char *) HT_12700
); break;
5851 case 12800: return ((char *) HT_12800
); break;
5852 case 12900: return ((char *) HT_12900
); break;
5853 case 13000: return ((char *) HT_13000
); break;
5854 case 13100: return ((char *) HT_13100
); break;
5855 case 13200: return ((char *) HT_13200
); break;
5856 case 13300: return ((char *) HT_13300
); break;
5857 case 13400: return ((char *) HT_13400
); break;
5858 case 13500: return ((char *) HT_13500
); break;
5859 case 13600: return ((char *) HT_13600
); break;
5862 return ((char *) "Unknown");
5865 char *strstatus (const uint devices_status
)
5867 switch (devices_status
)
5869 case STATUS_INIT
: return ((char *) ST_0000
); break;
5870 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5871 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5872 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5873 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5874 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5875 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5876 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5877 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5878 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5879 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5882 return ((char *) "Unknown");
5885 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5887 uint hash_type
= data
.hash_type
;
5888 uint hash_mode
= data
.hash_mode
;
5889 uint salt_type
= data
.salt_type
;
5890 uint opts_type
= data
.opts_type
;
5891 uint opti_type
= data
.opti_type
;
5892 uint dgst_size
= data
.dgst_size
;
5894 char *hashfile
= data
.hashfile
;
5898 uint digest_buf
[64] = { 0 };
5900 u64
*digest_buf64
= (u64
*) digest_buf
;
5902 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5904 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5906 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5912 case HASH_TYPE_DESCRYPT
:
5913 FP (digest_buf
[1], digest_buf
[0], tt
);
5916 case HASH_TYPE_DESRACF
:
5917 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5918 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5920 FP (digest_buf
[1], digest_buf
[0], tt
);
5924 FP (digest_buf
[1], digest_buf
[0], tt
);
5927 case HASH_TYPE_NETNTLM
:
5928 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5929 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5930 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5931 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5933 FP (digest_buf
[1], digest_buf
[0], tt
);
5934 FP (digest_buf
[3], digest_buf
[2], tt
);
5937 case HASH_TYPE_BSDICRYPT
:
5938 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5939 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5941 FP (digest_buf
[1], digest_buf
[0], tt
);
5946 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5951 digest_buf
[0] += MD4M_A
;
5952 digest_buf
[1] += MD4M_B
;
5953 digest_buf
[2] += MD4M_C
;
5954 digest_buf
[3] += MD4M_D
;
5958 digest_buf
[0] += MD5M_A
;
5959 digest_buf
[1] += MD5M_B
;
5960 digest_buf
[2] += MD5M_C
;
5961 digest_buf
[3] += MD5M_D
;
5964 case HASH_TYPE_SHA1
:
5965 digest_buf
[0] += SHA1M_A
;
5966 digest_buf
[1] += SHA1M_B
;
5967 digest_buf
[2] += SHA1M_C
;
5968 digest_buf
[3] += SHA1M_D
;
5969 digest_buf
[4] += SHA1M_E
;
5972 case HASH_TYPE_SHA256
:
5973 digest_buf
[0] += SHA256M_A
;
5974 digest_buf
[1] += SHA256M_B
;
5975 digest_buf
[2] += SHA256M_C
;
5976 digest_buf
[3] += SHA256M_D
;
5977 digest_buf
[4] += SHA256M_E
;
5978 digest_buf
[5] += SHA256M_F
;
5979 digest_buf
[6] += SHA256M_G
;
5980 digest_buf
[7] += SHA256M_H
;
5983 case HASH_TYPE_SHA384
:
5984 digest_buf64
[0] += SHA384M_A
;
5985 digest_buf64
[1] += SHA384M_B
;
5986 digest_buf64
[2] += SHA384M_C
;
5987 digest_buf64
[3] += SHA384M_D
;
5988 digest_buf64
[4] += SHA384M_E
;
5989 digest_buf64
[5] += SHA384M_F
;
5990 digest_buf64
[6] += 0;
5991 digest_buf64
[7] += 0;
5994 case HASH_TYPE_SHA512
:
5995 digest_buf64
[0] += SHA512M_A
;
5996 digest_buf64
[1] += SHA512M_B
;
5997 digest_buf64
[2] += SHA512M_C
;
5998 digest_buf64
[3] += SHA512M_D
;
5999 digest_buf64
[4] += SHA512M_E
;
6000 digest_buf64
[5] += SHA512M_F
;
6001 digest_buf64
[6] += SHA512M_G
;
6002 digest_buf64
[7] += SHA512M_H
;
6007 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6009 if (dgst_size
== DGST_SIZE_4_2
)
6011 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (dgst_size
== DGST_SIZE_4_4
)
6015 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6017 else if (dgst_size
== DGST_SIZE_4_5
)
6019 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6021 else if (dgst_size
== DGST_SIZE_4_6
)
6023 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6025 else if (dgst_size
== DGST_SIZE_4_8
)
6027 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6029 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6031 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6033 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6035 else if (hash_type
== HASH_TYPE_SHA384
)
6037 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6039 else if (hash_type
== HASH_TYPE_SHA512
)
6041 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6043 else if (hash_type
== HASH_TYPE_GOST
)
6045 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6048 else if (dgst_size
== DGST_SIZE_4_64
)
6050 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6052 else if (dgst_size
== DGST_SIZE_8_25
)
6054 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6058 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6059 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6060 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6066 memset (&salt
, 0, sizeof (salt_t
));
6068 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6070 char *ptr
= (char *) salt
.salt_buf
;
6072 uint len
= salt
.salt_len
;
6074 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6080 case HASH_TYPE_NETNTLM
:
6082 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6083 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6085 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6091 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6093 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6101 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6103 uint max
= salt
.salt_len
/ 4;
6107 for (uint i
= 0; i
< max
; i
++)
6109 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6113 if (opts_type
& OPTS_TYPE_ST_HEX
)
6115 char tmp
[64] = { 0 };
6117 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6119 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6124 memcpy (ptr
, tmp
, len
);
6127 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6129 memset (ptr
+ len
, 0, memset_size
);
6131 salt
.salt_len
= len
;
6135 // some modes require special encoding
6138 uint out_buf_plain
[256] = { 0 };
6139 uint out_buf_salt
[256] = { 0 };
6141 char tmp_buf
[1024] = { 0 };
6143 char *ptr_plain
= (char *) out_buf_plain
;
6144 char *ptr_salt
= (char *) out_buf_salt
;
6146 if (hash_mode
== 22)
6148 char username
[30] = { 0 };
6150 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6152 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6154 u16
*ptr
= (u16
*) digest_buf
;
6156 tmp_buf
[ 0] = sig
[0];
6157 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6158 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6159 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6160 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6161 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6162 tmp_buf
[ 6] = sig
[1];
6163 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6164 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6165 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6166 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6167 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6168 tmp_buf
[12] = sig
[2];
6169 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6170 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6171 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6172 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6173 tmp_buf
[17] = sig
[3];
6174 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6175 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6176 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6177 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6178 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6179 tmp_buf
[23] = sig
[4];
6180 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6181 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6182 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6183 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6184 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6185 tmp_buf
[29] = sig
[5];
6187 snprintf (out_buf
, len
-1, "%s:%s",
6191 else if (hash_mode
== 23)
6193 // do not show the skyper part in output
6195 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6197 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6199 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6206 else if (hash_mode
== 101)
6208 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6210 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6211 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6212 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6213 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6214 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6216 memcpy (tmp_buf
, digest_buf
, 20);
6218 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6220 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6222 else if (hash_mode
== 111)
6224 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6226 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6227 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6228 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6229 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6230 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6232 memcpy (tmp_buf
, digest_buf
, 20);
6233 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6235 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6237 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6239 else if ((hash_mode
== 122) || (hash_mode
== 125))
6241 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6242 (char *) salt
.salt_buf
,
6249 else if (hash_mode
== 124)
6251 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6252 (char *) salt
.salt_buf
,
6259 else if (hash_mode
== 131)
6261 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6262 (char *) salt
.salt_buf
,
6270 else if (hash_mode
== 132)
6272 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6273 (char *) salt
.salt_buf
,
6280 else if (hash_mode
== 133)
6282 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6284 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6285 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6286 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6287 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6288 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6290 memcpy (tmp_buf
, digest_buf
, 20);
6292 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6294 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6296 else if (hash_mode
== 141)
6298 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6300 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6302 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6304 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6306 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6307 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6308 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6309 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6310 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6312 memcpy (tmp_buf
, digest_buf
, 20);
6314 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6318 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6320 else if (hash_mode
== 400)
6322 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6324 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6325 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6326 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6327 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6329 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6331 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6333 else if (hash_mode
== 500)
6335 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6337 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6338 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6339 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6340 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6342 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6344 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6346 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6350 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6353 else if (hash_mode
== 501)
6355 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6357 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6358 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6360 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6362 else if (hash_mode
== 1421)
6364 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6366 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6382 else if (hash_mode
== 1441)
6384 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6386 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6388 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6390 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6392 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6393 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6394 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6395 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6396 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6397 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6398 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6399 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6401 memcpy (tmp_buf
, digest_buf
, 32);
6403 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6407 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6409 else if (hash_mode
== 1500)
6411 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6412 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6413 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6414 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6415 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6417 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6419 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6421 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6422 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6424 memcpy (tmp_buf
, digest_buf
, 8);
6426 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6428 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6432 else if (hash_mode
== 1600)
6434 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6436 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6437 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6438 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6439 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6441 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6443 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6445 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6449 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6452 else if (hash_mode
== 1711)
6454 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6456 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6457 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6458 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6459 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6460 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6461 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6462 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6463 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6465 memcpy (tmp_buf
, digest_buf
, 64);
6466 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6468 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6470 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6472 else if (hash_mode
== 1722)
6474 uint
*ptr
= digest_buf
;
6476 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6477 (unsigned char *) salt
.salt_buf
,
6487 else if (hash_mode
== 1731)
6489 uint
*ptr
= digest_buf
;
6491 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6492 (unsigned char *) salt
.salt_buf
,
6502 else if (hash_mode
== 1800)
6506 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6507 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6508 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6509 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6510 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6511 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6512 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6513 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6515 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6517 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6519 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6523 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6526 else if (hash_mode
== 2100)
6530 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6532 salt
.salt_iter
+ 1);
6534 uint signature_len
= strlen (out_buf
);
6536 pos
+= signature_len
;
6537 len
-= signature_len
;
6539 char *salt_ptr
= (char *) salt
.salt_buf
;
6541 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6543 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6544 byte_swap_32 (digest_buf
[0]),
6545 byte_swap_32 (digest_buf
[1]),
6546 byte_swap_32 (digest_buf
[2]),
6547 byte_swap_32 (digest_buf
[3]));
6549 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6551 memcpy (tmp_buf
, digest_buf
, 16);
6553 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6555 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6556 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6557 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6558 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6560 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6561 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6562 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6563 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6565 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6566 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6567 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6568 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6570 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6571 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6572 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6573 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6575 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6576 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6577 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6578 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6582 else if (hash_mode
== 2500)
6584 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6586 wpa_t
*wpa
= &wpas
[salt_pos
];
6588 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6589 (char *) salt
.salt_buf
,
6603 else if (hash_mode
== 4400)
6605 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6606 byte_swap_32 (digest_buf
[0]),
6607 byte_swap_32 (digest_buf
[1]),
6608 byte_swap_32 (digest_buf
[2]),
6609 byte_swap_32 (digest_buf
[3]));
6611 else if (hash_mode
== 4700)
6613 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6614 byte_swap_32 (digest_buf
[0]),
6615 byte_swap_32 (digest_buf
[1]),
6616 byte_swap_32 (digest_buf
[2]),
6617 byte_swap_32 (digest_buf
[3]),
6618 byte_swap_32 (digest_buf
[4]));
6620 else if (hash_mode
== 4800)
6622 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6624 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6629 byte_swap_32 (salt
.salt_buf
[0]),
6630 byte_swap_32 (salt
.salt_buf
[1]),
6631 byte_swap_32 (salt
.salt_buf
[2]),
6632 byte_swap_32 (salt
.salt_buf
[3]),
6635 else if (hash_mode
== 4900)
6637 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6638 byte_swap_32 (digest_buf
[0]),
6639 byte_swap_32 (digest_buf
[1]),
6640 byte_swap_32 (digest_buf
[2]),
6641 byte_swap_32 (digest_buf
[3]),
6642 byte_swap_32 (digest_buf
[4]));
6644 else if (hash_mode
== 5100)
6646 snprintf (out_buf
, len
-1, "%08x%08x",
6650 else if (hash_mode
== 5200)
6652 snprintf (out_buf
, len
-1, "%s", hashfile
);
6654 else if (hash_mode
== 5300)
6656 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6658 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6660 int buf_len
= len
-1;
6664 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6666 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6668 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6670 snprintf (out_buf
, buf_len
, ":");
6676 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6684 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6686 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6688 if ((i
== 0) || (i
== 5))
6690 snprintf (out_buf
, buf_len
, ":");
6696 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6704 for (uint i
= 0; i
< 4; i
++)
6708 snprintf (out_buf
, buf_len
, ":");
6714 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6720 else if (hash_mode
== 5400)
6722 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6724 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6726 int buf_len
= len
-1;
6730 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6732 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6734 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6736 snprintf (out_buf
, buf_len
, ":");
6742 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6750 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6752 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6754 if ((i
== 0) || (i
== 5))
6756 snprintf (out_buf
, buf_len
, ":");
6762 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6770 for (uint i
= 0; i
< 5; i
++)
6774 snprintf (out_buf
, buf_len
, ":");
6780 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6786 else if (hash_mode
== 5500)
6788 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6790 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6792 char user_buf
[64] = { 0 };
6793 char domain_buf
[64] = { 0 };
6794 char srvchall_buf
[1024] = { 0 };
6795 char clichall_buf
[1024] = { 0 };
6797 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6799 char *ptr
= (char *) netntlm
->userdomain_buf
;
6801 user_buf
[i
] = ptr
[j
];
6804 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6806 char *ptr
= (char *) netntlm
->userdomain_buf
;
6808 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6811 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6813 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6815 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6818 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6820 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6822 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6825 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6833 byte_swap_32 (salt
.salt_buf_pc
[0]),
6834 byte_swap_32 (salt
.salt_buf_pc
[1]),
6837 else if (hash_mode
== 5600)
6839 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6841 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6843 char user_buf
[64] = { 0 };
6844 char domain_buf
[64] = { 0 };
6845 char srvchall_buf
[1024] = { 0 };
6846 char clichall_buf
[1024] = { 0 };
6848 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6850 char *ptr
= (char *) netntlm
->userdomain_buf
;
6852 user_buf
[i
] = ptr
[j
];
6855 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6857 char *ptr
= (char *) netntlm
->userdomain_buf
;
6859 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6862 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6864 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6866 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6869 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6871 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6873 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6876 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6886 else if (hash_mode
== 5700)
6888 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6890 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6891 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6892 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6893 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6894 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6895 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6896 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6897 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6899 memcpy (tmp_buf
, digest_buf
, 32);
6901 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6905 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6907 else if (hash_mode
== 5800)
6909 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6910 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6911 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6912 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6913 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6915 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6922 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6924 snprintf (out_buf
, len
-1, "%s", hashfile
);
6926 else if (hash_mode
== 6300)
6928 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6930 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6931 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6932 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6933 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6935 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6937 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6939 else if (hash_mode
== 6400)
6941 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6943 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6945 else if (hash_mode
== 6500)
6947 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6949 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6951 else if (hash_mode
== 6600)
6953 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6955 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6957 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6958 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6960 uint buf_len
= len
- 1;
6962 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6965 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6967 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6972 else if (hash_mode
== 6700)
6974 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6976 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6978 else if (hash_mode
== 6800)
6980 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6982 else if (hash_mode
== 7100)
6984 uint
*ptr
= digest_buf
;
6986 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6988 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6990 uint esalt
[8] = { 0 };
6992 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6993 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6994 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6995 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6996 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6997 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6998 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6999 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7001 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",
7002 SIGNATURE_SHA512OSX
,
7004 esalt
[ 0], esalt
[ 1],
7005 esalt
[ 2], esalt
[ 3],
7006 esalt
[ 4], esalt
[ 5],
7007 esalt
[ 6], esalt
[ 7],
7015 ptr
[15], ptr
[14]);
7017 else if (hash_mode
== 7200)
7019 uint
*ptr
= digest_buf
;
7021 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7023 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7027 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7029 len_used
= strlen (out_buf
);
7031 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7033 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7035 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7038 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",
7046 ptr
[15], ptr
[14]);
7048 else if (hash_mode
== 7300)
7050 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7052 rakp_t
*rakp
= &rakps
[salt_pos
];
7054 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7056 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7059 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7066 else if (hash_mode
== 7400)
7068 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7070 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7071 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7072 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7073 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7074 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7075 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7076 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7077 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7079 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7081 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7083 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7087 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7090 else if (hash_mode
== 7500)
7092 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7094 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7096 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7097 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7099 char data
[128] = { 0 };
7101 char *ptr_data
= data
;
7103 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7105 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7108 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7110 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7115 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7117 (char *) krb5pa
->user
,
7118 (char *) krb5pa
->realm
,
7119 (char *) krb5pa
->salt
,
7122 else if (hash_mode
== 7700)
7124 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7125 (char *) salt
.salt_buf
,
7129 else if (hash_mode
== 7800)
7131 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7132 (char *) salt
.salt_buf
,
7139 else if (hash_mode
== 7900)
7141 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7145 char *tmp
= (char *) salt
.salt_buf_pc
;
7147 ptr_plain
[42] = tmp
[0];
7153 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7155 else if (hash_mode
== 8000)
7157 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7158 (unsigned char *) salt
.salt_buf
,
7168 else if (hash_mode
== 8100)
7170 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7171 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7173 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7174 (unsigned char *) salt
.salt_buf
,
7181 else if (hash_mode
== 8200)
7183 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7185 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7187 char data_buf
[4096] = { 0 };
7189 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7191 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7194 data_buf
[cloudkey
->data_len
* 2] = 0;
7196 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7197 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7198 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7199 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7200 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7201 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7202 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7203 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7205 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7206 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7207 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7208 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7210 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7226 else if (hash_mode
== 8300)
7228 char digest_buf_c
[34] = { 0 };
7230 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7231 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7232 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7233 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7234 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7236 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7238 digest_buf_c
[32] = 0;
7242 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7244 char domain_buf_c
[33] = { 0 };
7246 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7248 for (uint i
= 0; i
< salt_pc_len
; i
++)
7250 const char next
= domain_buf_c
[i
];
7252 domain_buf_c
[i
] = '.';
7257 domain_buf_c
[salt_pc_len
] = 0;
7261 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7263 else if (hash_mode
== 8500)
7265 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7267 else if (hash_mode
== 2612)
7269 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7271 (char *) salt
.salt_buf
,
7277 else if (hash_mode
== 3711)
7279 char *salt_ptr
= (char *) salt
.salt_buf
;
7281 salt_ptr
[salt
.salt_len
- 1] = 0;
7283 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7284 SIGNATURE_MEDIAWIKI_B
,
7291 else if (hash_mode
== 8800)
7293 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7295 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7297 char tmp
[3073] = { 0 };
7299 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7301 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7306 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7307 SIGNATURE_ANDROIDFDE
,
7308 byte_swap_32 (salt
.salt_buf
[0]),
7309 byte_swap_32 (salt
.salt_buf
[1]),
7310 byte_swap_32 (salt
.salt_buf
[2]),
7311 byte_swap_32 (salt
.salt_buf
[3]),
7312 byte_swap_32 (digest_buf
[0]),
7313 byte_swap_32 (digest_buf
[1]),
7314 byte_swap_32 (digest_buf
[2]),
7315 byte_swap_32 (digest_buf
[3]),
7318 else if (hash_mode
== 8900)
7320 uint N
= salt
.scrypt_N
;
7321 uint r
= salt
.scrypt_r
;
7322 uint p
= salt
.scrypt_p
;
7324 char base64_salt
[32] = { 0 };
7326 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7328 memset (tmp_buf
, 0, 46);
7330 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7331 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7332 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7333 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7334 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7335 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7336 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7337 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7338 digest_buf
[8] = 0; // needed for base64_encode ()
7340 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7342 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7350 else if (hash_mode
== 9000)
7352 snprintf (out_buf
, len
-1, "%s", hashfile
);
7354 else if (hash_mode
== 9200)
7358 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7360 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7362 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7366 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7367 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7368 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7369 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7370 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7371 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7372 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7373 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7374 digest_buf
[8] = 0; // needed for base64_encode ()
7376 char tmp_buf
[64] = { 0 };
7378 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7379 tmp_buf
[43] = 0; // cut it here
7383 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7385 else if (hash_mode
== 9300)
7387 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7388 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7389 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7390 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7391 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7392 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7393 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7394 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7395 digest_buf
[8] = 0; // needed for base64_encode ()
7397 char tmp_buf
[64] = { 0 };
7399 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7400 tmp_buf
[43] = 0; // cut it here
7402 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7404 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7406 else if (hash_mode
== 9400)
7408 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7410 office2007_t
*office2007
= &office2007s
[salt_pos
];
7412 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7413 SIGNATURE_OFFICE2007
,
7416 office2007
->keySize
,
7422 office2007
->encryptedVerifier
[0],
7423 office2007
->encryptedVerifier
[1],
7424 office2007
->encryptedVerifier
[2],
7425 office2007
->encryptedVerifier
[3],
7426 office2007
->encryptedVerifierHash
[0],
7427 office2007
->encryptedVerifierHash
[1],
7428 office2007
->encryptedVerifierHash
[2],
7429 office2007
->encryptedVerifierHash
[3],
7430 office2007
->encryptedVerifierHash
[4]);
7432 else if (hash_mode
== 9500)
7434 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7436 office2010_t
*office2010
= &office2010s
[salt_pos
];
7438 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,
7444 office2010
->encryptedVerifier
[0],
7445 office2010
->encryptedVerifier
[1],
7446 office2010
->encryptedVerifier
[2],
7447 office2010
->encryptedVerifier
[3],
7448 office2010
->encryptedVerifierHash
[0],
7449 office2010
->encryptedVerifierHash
[1],
7450 office2010
->encryptedVerifierHash
[2],
7451 office2010
->encryptedVerifierHash
[3],
7452 office2010
->encryptedVerifierHash
[4],
7453 office2010
->encryptedVerifierHash
[5],
7454 office2010
->encryptedVerifierHash
[6],
7455 office2010
->encryptedVerifierHash
[7]);
7457 else if (hash_mode
== 9600)
7459 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7461 office2013_t
*office2013
= &office2013s
[salt_pos
];
7463 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,
7469 office2013
->encryptedVerifier
[0],
7470 office2013
->encryptedVerifier
[1],
7471 office2013
->encryptedVerifier
[2],
7472 office2013
->encryptedVerifier
[3],
7473 office2013
->encryptedVerifierHash
[0],
7474 office2013
->encryptedVerifierHash
[1],
7475 office2013
->encryptedVerifierHash
[2],
7476 office2013
->encryptedVerifierHash
[3],
7477 office2013
->encryptedVerifierHash
[4],
7478 office2013
->encryptedVerifierHash
[5],
7479 office2013
->encryptedVerifierHash
[6],
7480 office2013
->encryptedVerifierHash
[7]);
7482 else if (hash_mode
== 9700)
7484 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7486 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7488 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7489 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7490 byte_swap_32 (salt
.salt_buf
[0]),
7491 byte_swap_32 (salt
.salt_buf
[1]),
7492 byte_swap_32 (salt
.salt_buf
[2]),
7493 byte_swap_32 (salt
.salt_buf
[3]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7503 else if (hash_mode
== 9710)
7505 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7507 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7509 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7510 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7511 byte_swap_32 (salt
.salt_buf
[0]),
7512 byte_swap_32 (salt
.salt_buf
[1]),
7513 byte_swap_32 (salt
.salt_buf
[2]),
7514 byte_swap_32 (salt
.salt_buf
[3]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7524 else if (hash_mode
== 9720)
7526 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7528 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7530 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7532 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7533 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7534 byte_swap_32 (salt
.salt_buf
[0]),
7535 byte_swap_32 (salt
.salt_buf
[1]),
7536 byte_swap_32 (salt
.salt_buf
[2]),
7537 byte_swap_32 (salt
.salt_buf
[3]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7552 else if (hash_mode
== 9800)
7554 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7556 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7558 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7559 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7564 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7574 else if (hash_mode
== 9810)
7576 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7578 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7580 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7581 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7586 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7596 else if (hash_mode
== 9820)
7598 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7600 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7602 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7604 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7605 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7610 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7625 else if (hash_mode
== 10000)
7629 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7631 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7633 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7637 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7638 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7639 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7640 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7641 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7642 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7643 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7644 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7645 digest_buf
[8] = 0; // needed for base64_encode ()
7647 char tmp_buf
[64] = { 0 };
7649 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7653 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7655 else if (hash_mode
== 10100)
7657 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
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]));
7667 else if (hash_mode
== 10200)
7669 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7671 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7675 char challenge
[100] = { 0 };
7677 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7681 char tmp_buf
[100] = { 0 };
7683 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7684 (char *) cram_md5
->user
,
7690 char response
[100] = { 0 };
7692 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7694 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7696 else if (hash_mode
== 10300)
7698 char tmp_buf
[100] = { 0 };
7700 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7701 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7703 uint tmp_len
= 20 + salt
.salt_len
;
7707 char base64_encoded
[100] = { 0 };
7709 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7711 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7713 else if (hash_mode
== 10400)
7715 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7717 pdf_t
*pdf
= &pdfs
[salt_pos
];
7719 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",
7727 byte_swap_32 (pdf
->id_buf
[0]),
7728 byte_swap_32 (pdf
->id_buf
[1]),
7729 byte_swap_32 (pdf
->id_buf
[2]),
7730 byte_swap_32 (pdf
->id_buf
[3]),
7732 byte_swap_32 (pdf
->u_buf
[0]),
7733 byte_swap_32 (pdf
->u_buf
[1]),
7734 byte_swap_32 (pdf
->u_buf
[2]),
7735 byte_swap_32 (pdf
->u_buf
[3]),
7736 byte_swap_32 (pdf
->u_buf
[4]),
7737 byte_swap_32 (pdf
->u_buf
[5]),
7738 byte_swap_32 (pdf
->u_buf
[6]),
7739 byte_swap_32 (pdf
->u_buf
[7]),
7741 byte_swap_32 (pdf
->o_buf
[0]),
7742 byte_swap_32 (pdf
->o_buf
[1]),
7743 byte_swap_32 (pdf
->o_buf
[2]),
7744 byte_swap_32 (pdf
->o_buf
[3]),
7745 byte_swap_32 (pdf
->o_buf
[4]),
7746 byte_swap_32 (pdf
->o_buf
[5]),
7747 byte_swap_32 (pdf
->o_buf
[6]),
7748 byte_swap_32 (pdf
->o_buf
[7])
7751 else if (hash_mode
== 10410)
7753 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7755 pdf_t
*pdf
= &pdfs
[salt_pos
];
7757 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",
7765 byte_swap_32 (pdf
->id_buf
[0]),
7766 byte_swap_32 (pdf
->id_buf
[1]),
7767 byte_swap_32 (pdf
->id_buf
[2]),
7768 byte_swap_32 (pdf
->id_buf
[3]),
7770 byte_swap_32 (pdf
->u_buf
[0]),
7771 byte_swap_32 (pdf
->u_buf
[1]),
7772 byte_swap_32 (pdf
->u_buf
[2]),
7773 byte_swap_32 (pdf
->u_buf
[3]),
7774 byte_swap_32 (pdf
->u_buf
[4]),
7775 byte_swap_32 (pdf
->u_buf
[5]),
7776 byte_swap_32 (pdf
->u_buf
[6]),
7777 byte_swap_32 (pdf
->u_buf
[7]),
7779 byte_swap_32 (pdf
->o_buf
[0]),
7780 byte_swap_32 (pdf
->o_buf
[1]),
7781 byte_swap_32 (pdf
->o_buf
[2]),
7782 byte_swap_32 (pdf
->o_buf
[3]),
7783 byte_swap_32 (pdf
->o_buf
[4]),
7784 byte_swap_32 (pdf
->o_buf
[5]),
7785 byte_swap_32 (pdf
->o_buf
[6]),
7786 byte_swap_32 (pdf
->o_buf
[7])
7789 else if (hash_mode
== 10420)
7791 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7793 pdf_t
*pdf
= &pdfs
[salt_pos
];
7795 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7797 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",
7805 byte_swap_32 (pdf
->id_buf
[0]),
7806 byte_swap_32 (pdf
->id_buf
[1]),
7807 byte_swap_32 (pdf
->id_buf
[2]),
7808 byte_swap_32 (pdf
->id_buf
[3]),
7810 byte_swap_32 (pdf
->u_buf
[0]),
7811 byte_swap_32 (pdf
->u_buf
[1]),
7812 byte_swap_32 (pdf
->u_buf
[2]),
7813 byte_swap_32 (pdf
->u_buf
[3]),
7814 byte_swap_32 (pdf
->u_buf
[4]),
7815 byte_swap_32 (pdf
->u_buf
[5]),
7816 byte_swap_32 (pdf
->u_buf
[6]),
7817 byte_swap_32 (pdf
->u_buf
[7]),
7819 byte_swap_32 (pdf
->o_buf
[0]),
7820 byte_swap_32 (pdf
->o_buf
[1]),
7821 byte_swap_32 (pdf
->o_buf
[2]),
7822 byte_swap_32 (pdf
->o_buf
[3]),
7823 byte_swap_32 (pdf
->o_buf
[4]),
7824 byte_swap_32 (pdf
->o_buf
[5]),
7825 byte_swap_32 (pdf
->o_buf
[6]),
7826 byte_swap_32 (pdf
->o_buf
[7]),
7834 else if (hash_mode
== 10500)
7836 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7838 pdf_t
*pdf
= &pdfs
[salt_pos
];
7840 if (pdf
->id_len
== 32)
7842 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",
7850 byte_swap_32 (pdf
->id_buf
[0]),
7851 byte_swap_32 (pdf
->id_buf
[1]),
7852 byte_swap_32 (pdf
->id_buf
[2]),
7853 byte_swap_32 (pdf
->id_buf
[3]),
7854 byte_swap_32 (pdf
->id_buf
[4]),
7855 byte_swap_32 (pdf
->id_buf
[5]),
7856 byte_swap_32 (pdf
->id_buf
[6]),
7857 byte_swap_32 (pdf
->id_buf
[7]),
7859 byte_swap_32 (pdf
->u_buf
[0]),
7860 byte_swap_32 (pdf
->u_buf
[1]),
7861 byte_swap_32 (pdf
->u_buf
[2]),
7862 byte_swap_32 (pdf
->u_buf
[3]),
7863 byte_swap_32 (pdf
->u_buf
[4]),
7864 byte_swap_32 (pdf
->u_buf
[5]),
7865 byte_swap_32 (pdf
->u_buf
[6]),
7866 byte_swap_32 (pdf
->u_buf
[7]),
7868 byte_swap_32 (pdf
->o_buf
[0]),
7869 byte_swap_32 (pdf
->o_buf
[1]),
7870 byte_swap_32 (pdf
->o_buf
[2]),
7871 byte_swap_32 (pdf
->o_buf
[3]),
7872 byte_swap_32 (pdf
->o_buf
[4]),
7873 byte_swap_32 (pdf
->o_buf
[5]),
7874 byte_swap_32 (pdf
->o_buf
[6]),
7875 byte_swap_32 (pdf
->o_buf
[7])
7880 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",
7888 byte_swap_32 (pdf
->id_buf
[0]),
7889 byte_swap_32 (pdf
->id_buf
[1]),
7890 byte_swap_32 (pdf
->id_buf
[2]),
7891 byte_swap_32 (pdf
->id_buf
[3]),
7893 byte_swap_32 (pdf
->u_buf
[0]),
7894 byte_swap_32 (pdf
->u_buf
[1]),
7895 byte_swap_32 (pdf
->u_buf
[2]),
7896 byte_swap_32 (pdf
->u_buf
[3]),
7897 byte_swap_32 (pdf
->u_buf
[4]),
7898 byte_swap_32 (pdf
->u_buf
[5]),
7899 byte_swap_32 (pdf
->u_buf
[6]),
7900 byte_swap_32 (pdf
->u_buf
[7]),
7902 byte_swap_32 (pdf
->o_buf
[0]),
7903 byte_swap_32 (pdf
->o_buf
[1]),
7904 byte_swap_32 (pdf
->o_buf
[2]),
7905 byte_swap_32 (pdf
->o_buf
[3]),
7906 byte_swap_32 (pdf
->o_buf
[4]),
7907 byte_swap_32 (pdf
->o_buf
[5]),
7908 byte_swap_32 (pdf
->o_buf
[6]),
7909 byte_swap_32 (pdf
->o_buf
[7])
7913 else if (hash_mode
== 10600)
7915 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7917 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7918 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7920 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7922 else if (hash_mode
== 10700)
7924 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7926 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7927 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7929 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7931 else if (hash_mode
== 10900)
7933 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7935 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7936 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7938 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7940 else if (hash_mode
== 11100)
7942 u32 salt_challenge
= salt
.salt_buf
[0];
7944 salt_challenge
= byte_swap_32 (salt_challenge
);
7946 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7948 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7949 SIGNATURE_POSTGRESQL_AUTH
,
7957 else if (hash_mode
== 11200)
7959 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7960 SIGNATURE_MYSQL_AUTH
,
7961 (unsigned char *) salt
.salt_buf
,
7968 else if (hash_mode
== 11300)
7970 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7972 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7974 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7975 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7976 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7978 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7979 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7980 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7982 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7984 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7986 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7989 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7991 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7993 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7996 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7998 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8000 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8003 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8004 SIGNATURE_BITCOIN_WALLET
,
8008 (unsigned char *) salt
.salt_buf
,
8016 free (cry_master_buf
);
8018 free (public_key_buf
);
8020 else if (hash_mode
== 11400)
8022 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8024 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8025 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8027 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8029 else if (hash_mode
== 11600)
8031 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8033 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8035 const uint data_len
= seven_zip
->data_len
;
8037 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8039 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8041 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8043 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8046 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8047 SIGNATURE_SEVEN_ZIP
,
8051 (char *) seven_zip
->salt_buf
,
8053 seven_zip
->iv_buf
[0],
8054 seven_zip
->iv_buf
[1],
8055 seven_zip
->iv_buf
[2],
8056 seven_zip
->iv_buf
[3],
8058 seven_zip
->data_len
,
8059 seven_zip
->unpack_size
,
8064 else if (hash_mode
== 11700)
8066 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8076 else if (hash_mode
== 11800)
8078 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8096 else if (hash_mode
== 11900)
8098 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8100 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8101 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8103 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8105 else if (hash_mode
== 12000)
8107 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8109 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8110 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8112 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8114 else if (hash_mode
== 12100)
8116 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8118 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8119 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8121 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8123 else if (hash_mode
== 12200)
8125 uint
*ptr_digest
= digest_buf
;
8126 uint
*ptr_salt
= salt
.salt_buf
;
8128 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8135 else if (hash_mode
== 12300)
8137 uint
*ptr_digest
= digest_buf
;
8138 uint
*ptr_salt
= salt
.salt_buf
;
8140 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",
8141 ptr_digest
[ 0], ptr_digest
[ 1],
8142 ptr_digest
[ 2], ptr_digest
[ 3],
8143 ptr_digest
[ 4], ptr_digest
[ 5],
8144 ptr_digest
[ 6], ptr_digest
[ 7],
8145 ptr_digest
[ 8], ptr_digest
[ 9],
8146 ptr_digest
[10], ptr_digest
[11],
8147 ptr_digest
[12], ptr_digest
[13],
8148 ptr_digest
[14], ptr_digest
[15],
8154 else if (hash_mode
== 12400)
8156 // encode iteration count
8158 char salt_iter
[5] = { 0 };
8160 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8161 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8162 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8163 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8168 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8169 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8170 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8171 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8176 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8178 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8179 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8181 memcpy (tmp_buf
, digest_buf
, 8);
8183 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8187 // fill the resulting buffer
8189 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8191 else if (hash_mode
== 12500)
8193 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8195 byte_swap_32 (salt
.salt_buf
[0]),
8196 byte_swap_32 (salt
.salt_buf
[1]),
8202 else if (hash_mode
== 12600)
8204 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8205 digest_buf
[0] + salt
.salt_buf_pc
[0],
8206 digest_buf
[1] + salt
.salt_buf_pc
[1],
8207 digest_buf
[2] + salt
.salt_buf_pc
[2],
8208 digest_buf
[3] + salt
.salt_buf_pc
[3],
8209 digest_buf
[4] + salt
.salt_buf_pc
[4],
8210 digest_buf
[5] + salt
.salt_buf_pc
[5],
8211 digest_buf
[6] + salt
.salt_buf_pc
[6],
8212 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8214 else if (hash_mode
== 12700)
8216 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8218 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8219 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8221 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8223 else if (hash_mode
== 12800)
8225 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8227 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",
8240 byte_swap_32 (digest_buf
[0]),
8241 byte_swap_32 (digest_buf
[1]),
8242 byte_swap_32 (digest_buf
[2]),
8243 byte_swap_32 (digest_buf
[3]),
8244 byte_swap_32 (digest_buf
[4]),
8245 byte_swap_32 (digest_buf
[5]),
8246 byte_swap_32 (digest_buf
[6]),
8247 byte_swap_32 (digest_buf
[7])
8250 else if (hash_mode
== 12900)
8252 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",
8261 byte_swap_32 (digest_buf
[0]),
8262 byte_swap_32 (digest_buf
[1]),
8263 byte_swap_32 (digest_buf
[2]),
8264 byte_swap_32 (digest_buf
[3]),
8265 byte_swap_32 (digest_buf
[4]),
8266 byte_swap_32 (digest_buf
[5]),
8267 byte_swap_32 (digest_buf
[6]),
8268 byte_swap_32 (digest_buf
[7]),
8275 else if (hash_mode
== 13000)
8277 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8279 rar5_t
*rar5
= &rar5s
[salt_pos
];
8281 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8291 byte_swap_32 (digest_buf
[0]),
8292 byte_swap_32 (digest_buf
[1])
8295 else if (hash_mode
== 13100)
8297 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8299 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8301 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8302 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8304 char data
[2560 * 4 * 2] = { 0 };
8306 char *ptr_data
= data
;
8308 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8309 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8314 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8315 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8317 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8319 (char *) krb5tgs
->account_info
,
8323 else if (hash_mode
== 13200)
8325 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8339 else if (hash_mode
== 13300)
8341 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8342 SIGNATURE_AXCRYPT_SHA1
,
8348 else if (hash_mode
== 13400)
8350 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8352 keepass_t
*keepass
= &keepasss
[salt_pos
];
8354 u32 version
= (u32
) keepass
->version
;
8355 u32 rounds
= salt
.salt_iter
;
8356 u32 algorithm
= (u32
) keepass
->algorithm
;
8357 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8359 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8360 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8361 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8362 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8363 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8365 /* specific to version 1 */
8369 /* specific to version 2 */
8370 u32 expected_bytes_len
;
8371 u32
*ptr_expected_bytes
;
8373 u32 final_random_seed_len
;
8374 u32 transf_random_seed_len
;
8376 u32 contents_hash_len
;
8378 transf_random_seed_len
= 8;
8380 contents_hash_len
= 8;
8381 final_random_seed_len
= 8;
8384 final_random_seed_len
= 4;
8386 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8392 char *ptr_data
= out_buf
;
8394 ptr_data
+= strlen(out_buf
);
8399 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8400 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8405 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8406 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8411 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8412 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8419 contents_len
= (u32
) keepass
->contents_len
;
8420 ptr_contents
= (u32
*) keepass
->contents
;
8422 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8423 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8435 char ptr_contents_len
[10] = { 0 };
8437 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8439 sprintf (ptr_data
, "%d", contents_len
);
8441 ptr_data
+= strlen(ptr_contents_len
);
8446 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8447 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8449 else if (version
== 2)
8451 expected_bytes_len
= 8;
8452 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8454 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8455 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8460 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8461 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8475 sprintf (ptr_data
, "%d", keyfile_len
);
8482 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8483 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8486 else if (hash_mode
== 13500)
8488 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8490 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8492 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8494 char pstoken_tmp
[1024 + 1] = { 0 };
8496 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8498 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8500 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8503 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8511 else if (hash_mode
== 13600)
8513 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8515 zip2_t
*zip2
= &zip2s
[salt_pos
];
8517 const u32 salt_len
= zip2
->salt_len
;
8519 char salt_tmp
[32 + 1] = { 0 };
8521 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8523 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8525 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8528 const u32 data_len
= zip2
->data_len
;
8530 char data_tmp
[8192 + 1] = { 0 };
8532 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8534 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8536 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8539 const u32 auth_len
= zip2
->auth_len
;
8541 char auth_tmp
[20 + 1] = { 0 };
8543 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8545 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8547 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8550 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8551 SIGNATURE_ZIP2_START
,
8557 zip2
->compress_length
,
8560 SIGNATURE_ZIP2_STOP
);
8564 if (hash_type
== HASH_TYPE_MD4
)
8566 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8572 else if (hash_type
== HASH_TYPE_MD5
)
8574 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8580 else if (hash_type
== HASH_TYPE_SHA1
)
8582 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8589 else if (hash_type
== HASH_TYPE_SHA256
)
8591 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8601 else if (hash_type
== HASH_TYPE_SHA384
)
8603 uint
*ptr
= digest_buf
;
8605 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8613 else if (hash_type
== HASH_TYPE_SHA512
)
8615 uint
*ptr
= digest_buf
;
8617 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8627 else if (hash_type
== HASH_TYPE_LM
)
8629 snprintf (out_buf
, len
-1, "%08x%08x",
8633 else if (hash_type
== HASH_TYPE_ORACLEH
)
8635 snprintf (out_buf
, len
-1, "%08X%08X",
8639 else if (hash_type
== HASH_TYPE_BCRYPT
)
8641 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8642 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8644 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8646 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8648 else if (hash_type
== HASH_TYPE_KECCAK
)
8650 uint
*ptr
= digest_buf
;
8652 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",
8680 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8682 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8684 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8691 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8693 digest_buf
[ 0] = digest_buf
[ 0];
8694 digest_buf
[ 1] = digest_buf
[ 1];
8695 digest_buf
[ 2] = digest_buf
[ 2];
8696 digest_buf
[ 3] = digest_buf
[ 3];
8697 digest_buf
[ 4] = digest_buf
[ 4];
8698 digest_buf
[ 5] = digest_buf
[ 5];
8699 digest_buf
[ 6] = digest_buf
[ 6];
8700 digest_buf
[ 7] = digest_buf
[ 7];
8701 digest_buf
[ 8] = digest_buf
[ 8];
8702 digest_buf
[ 9] = digest_buf
[ 9];
8703 digest_buf
[10] = digest_buf
[10];
8704 digest_buf
[11] = digest_buf
[11];
8705 digest_buf
[12] = digest_buf
[12];
8706 digest_buf
[13] = digest_buf
[13];
8707 digest_buf
[14] = digest_buf
[14];
8708 digest_buf
[15] = digest_buf
[15];
8710 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8728 else if (hash_type
== HASH_TYPE_GOST
)
8730 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8740 else if (hash_type
== HASH_TYPE_MYSQL
)
8742 snprintf (out_buf
, len
-1, "%08x%08x",
8746 else if (hash_type
== HASH_TYPE_LOTUS5
)
8748 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8754 else if (hash_type
== HASH_TYPE_LOTUS6
)
8756 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8757 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8758 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8759 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8761 char buf
[16] = { 0 };
8763 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8764 memcpy (buf
+ 5, digest_buf
, 9);
8768 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8770 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8773 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8775 else if (hash_type
== HASH_TYPE_LOTUS8
)
8777 char buf
[52] = { 0 };
8781 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8787 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8791 buf
[26] = salt
.salt_buf_pc
[0];
8792 buf
[27] = salt
.salt_buf_pc
[1];
8796 memcpy (buf
+ 28, digest_buf
, 8);
8798 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8802 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8804 else if (hash_type
== HASH_TYPE_CRC32
)
8806 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8810 if (salt_type
== SALT_TYPE_INTERN
)
8812 size_t pos
= strlen (out_buf
);
8814 out_buf
[pos
] = data
.separator
;
8816 char *ptr
= (char *) salt
.salt_buf
;
8818 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8820 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8824 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8826 memset (hccap
, 0, sizeof (hccap_t
));
8828 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8830 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8832 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8833 wpa_t
*wpa
= &wpas
[salt_pos
];
8835 hccap
->keyver
= wpa
->keyver
;
8837 hccap
->eapol_size
= wpa
->eapol_size
;
8839 if (wpa
->keyver
!= 1)
8841 uint eapol_tmp
[64] = { 0 };
8843 for (uint i
= 0; i
< 64; i
++)
8845 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8848 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8852 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8855 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8856 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8857 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8858 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8860 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8862 uint dgst_size
= data
.dgst_size
;
8864 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8866 if (wpa
->keyver
!= 1)
8868 uint digest_tmp
[4] = { 0 };
8870 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8871 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8872 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8873 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8875 memcpy (hccap
->keymic
, digest_tmp
, 16);
8879 memcpy (hccap
->keymic
, digest_ptr
, 16);
8883 void SuspendThreads ()
8885 if (data
.devices_status
== STATUS_RUNNING
)
8887 hc_timer_set (&data
.timer_paused
);
8889 data
.devices_status
= STATUS_PAUSED
;
8891 log_info ("Paused");
8895 void ResumeThreads ()
8897 if (data
.devices_status
== STATUS_PAUSED
)
8901 hc_timer_get (data
.timer_paused
, ms_paused
);
8903 data
.ms_paused
+= ms_paused
;
8905 data
.devices_status
= STATUS_RUNNING
;
8907 log_info ("Resumed");
8913 if (data
.devices_status
!= STATUS_RUNNING
) return;
8915 data
.devices_status
= STATUS_BYPASS
;
8917 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8920 void stop_at_checkpoint ()
8922 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8924 if (data
.devices_status
!= STATUS_RUNNING
) return;
8927 // this feature only makes sense if --restore-disable was not specified
8929 if (data
.restore_disable
== 1)
8931 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8936 // check if monitoring of Restore Point updates should be enabled or disabled
8938 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8940 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8942 // save the current restore point value
8944 data
.checkpoint_cur_words
= get_lowest_words_done ();
8946 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8950 data
.devices_status
= STATUS_RUNNING
;
8952 // reset the global value for checkpoint checks
8954 data
.checkpoint_cur_words
= 0;
8956 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8962 if (data
.devices_status
== STATUS_INIT
) return;
8963 if (data
.devices_status
== STATUS_STARTING
) return;
8965 data
.devices_status
= STATUS_ABORTED
;
8970 if (data
.devices_status
== STATUS_INIT
) return;
8971 if (data
.devices_status
== STATUS_STARTING
) return;
8973 data
.devices_status
= STATUS_QUIT
;
8976 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8978 FILE *fp
= fopen (kernel_file
, "rb");
8984 memset (&st
, 0, sizeof (st
));
8986 stat (kernel_file
, &st
);
8988 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8990 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8992 if (num_read
!= (size_t) st
.st_size
)
8994 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9001 buf
[st
.st_size
] = 0;
9003 for (int i
= 0; i
< num_devices
; i
++)
9005 kernel_lengths
[i
] = (size_t) st
.st_size
;
9007 kernel_sources
[i
] = buf
;
9012 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9020 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9022 if (binary_size
> 0)
9024 FILE *fp
= fopen (dst
, "wb");
9027 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9038 restore_data_t
*init_restore (int argc
, char **argv
)
9040 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9042 if (data
.restore_disable
== 0)
9044 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9048 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9052 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9061 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9063 int pidbin_len
= -1;
9066 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9068 FILE *fd
= fopen (pidbin
, "rb");
9072 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9074 pidbin
[pidbin_len
] = 0;
9078 char *argv0_r
= strrchr (argv
[0], '/');
9080 char *pidbin_r
= strrchr (pidbin
, '/');
9082 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9084 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9086 if (strcmp (argv0_r
, pidbin_r
) == 0)
9088 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9095 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9097 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9099 int pidbin2_len
= -1;
9101 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9102 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9104 pidbin
[pidbin_len
] = 0;
9105 pidbin2
[pidbin2_len
] = 0;
9109 if (strcmp (pidbin
, pidbin2
) == 0)
9111 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9124 if (rd
->version_bin
< RESTORE_MIN
)
9126 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9133 memset (rd
, 0, sizeof (restore_data_t
));
9135 rd
->version_bin
= VERSION_BIN
;
9138 rd
->pid
= getpid ();
9140 rd
->pid
= GetCurrentProcessId ();
9143 if (getcwd (rd
->cwd
, 255) == NULL
)
9156 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9158 FILE *fp
= fopen (eff_restore_file
, "rb");
9162 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9167 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9169 log_error ("ERROR: cannot read %s", eff_restore_file
);
9174 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9176 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9178 for (uint i
= 0; i
< rd
->argc
; i
++)
9180 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9182 log_error ("ERROR: cannot read %s", eff_restore_file
);
9187 size_t len
= strlen (buf
);
9189 if (len
) buf
[len
- 1] = 0;
9191 rd
->argv
[i
] = mystrdup (buf
);
9198 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9200 if (chdir (rd
->cwd
))
9202 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9203 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9204 " https://github.com/philsmd/analyze_hc_restore\n"
9205 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9211 u64
get_lowest_words_done ()
9215 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9217 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9219 if (device_param
->skipped
) continue;
9221 const u64 words_done
= device_param
->words_done
;
9223 if (words_done
< words_cur
) words_cur
= words_done
;
9226 // It's possible that a device's workload isn't finished right after a restore-case.
9227 // In that case, this function would return 0 and overwrite the real restore point
9228 // There's also data.words_cur which is set to rd->words_cur but it changes while
9229 // the attack is running therefore we should stick to rd->words_cur.
9230 // Note that -s influences rd->words_cur we should keep a close look on that.
9232 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9237 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9239 u64 words_cur
= get_lowest_words_done ();
9241 rd
->words_cur
= words_cur
;
9243 FILE *fp
= fopen (new_restore_file
, "wb");
9247 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9252 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9254 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9259 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9261 for (uint i
= 0; i
< rd
->argc
; i
++)
9263 fprintf (fp
, "%s", rd
->argv
[i
]);
9269 fsync (fileno (fp
));
9274 void cycle_restore ()
9276 const char *eff_restore_file
= data
.eff_restore_file
;
9277 const char *new_restore_file
= data
.new_restore_file
;
9279 restore_data_t
*rd
= data
.rd
;
9281 write_restore (new_restore_file
, rd
);
9285 memset (&st
, 0, sizeof(st
));
9287 if (stat (eff_restore_file
, &st
) == 0)
9289 if (unlink (eff_restore_file
))
9291 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9295 if (rename (new_restore_file
, eff_restore_file
))
9297 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9301 void check_checkpoint ()
9303 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9305 u64 words_cur
= get_lowest_words_done ();
9307 if (words_cur
!= data
.checkpoint_cur_words
)
9317 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9321 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9323 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9325 myfree (alias
->device_name
);
9326 myfree (alias
->alias_name
);
9329 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9331 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9333 myfree (entry
->device_name
);
9336 myfree (tuning_db
->alias_buf
);
9337 myfree (tuning_db
->entry_buf
);
9342 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9344 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9346 int num_lines
= count_lines (fp
);
9348 // a bit over-allocated
9350 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9351 tuning_db
->alias_cnt
= 0;
9353 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9354 tuning_db
->entry_cnt
= 0;
9359 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9361 FILE *fp
= fopen (tuning_db_file
, "rb");
9365 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9370 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9376 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9380 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9382 if (line_buf
== NULL
) break;
9386 const int line_len
= in_superchop (line_buf
);
9388 if (line_len
== 0) continue;
9390 if (line_buf
[0] == '#') continue;
9394 char *token_ptr
[7] = { NULL
};
9398 char *next
= strtok (line_buf
, "\t ");
9400 token_ptr
[token_cnt
] = next
;
9404 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9406 token_ptr
[token_cnt
] = next
;
9413 char *device_name
= token_ptr
[0];
9414 char *alias_name
= token_ptr
[1];
9416 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9418 alias
->device_name
= mystrdup (device_name
);
9419 alias
->alias_name
= mystrdup (alias_name
);
9421 tuning_db
->alias_cnt
++;
9423 else if (token_cnt
== 6)
9425 if ((token_ptr
[1][0] != '0') &&
9426 (token_ptr
[1][0] != '1') &&
9427 (token_ptr
[1][0] != '3') &&
9428 (token_ptr
[1][0] != '*'))
9430 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9435 if ((token_ptr
[3][0] != '1') &&
9436 (token_ptr
[3][0] != '2') &&
9437 (token_ptr
[3][0] != '4') &&
9438 (token_ptr
[3][0] != '8') &&
9439 (token_ptr
[3][0] != 'N'))
9441 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9446 char *device_name
= token_ptr
[0];
9448 int attack_mode
= -1;
9450 int vector_width
= -1;
9451 int kernel_accel
= -1;
9452 int kernel_loops
= -1;
9454 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9455 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9456 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9458 if (token_ptr
[4][0] != 'A')
9460 kernel_accel
= atoi (token_ptr
[4]);
9462 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9464 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9474 if (token_ptr
[5][0] != 'A')
9476 kernel_loops
= atoi (token_ptr
[5]);
9478 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9480 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9490 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9492 entry
->device_name
= mystrdup (device_name
);
9493 entry
->attack_mode
= attack_mode
;
9494 entry
->hash_type
= hash_type
;
9495 entry
->vector_width
= vector_width
;
9496 entry
->kernel_accel
= kernel_accel
;
9497 entry
->kernel_loops
= kernel_loops
;
9499 tuning_db
->entry_cnt
++;
9503 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9513 // todo: print loaded 'cnt' message
9515 // sort the database
9517 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9518 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9523 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9525 static tuning_db_entry_t s
;
9527 // first we need to convert all spaces in the device_name to underscore
9529 char *device_name_nospace
= strdup (device_param
->device_name
);
9531 int device_name_length
= strlen (device_name_nospace
);
9535 for (i
= 0; i
< device_name_length
; i
++)
9537 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9540 // find out if there's an alias configured
9542 tuning_db_alias_t a
;
9544 a
.device_name
= device_name_nospace
;
9546 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
);
9548 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9550 // attack-mode 6 and 7 are attack-mode 1 basically
9552 if (attack_mode
== 6) attack_mode
= 1;
9553 if (attack_mode
== 7) attack_mode
= 1;
9555 // bsearch is not ideal but fast enough
9557 s
.device_name
= device_name_nospace
;
9558 s
.attack_mode
= attack_mode
;
9559 s
.hash_type
= hash_type
;
9561 tuning_db_entry_t
*entry
= NULL
;
9563 // this will produce all 2^3 combinations required
9565 for (i
= 0; i
< 8; i
++)
9567 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9568 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9569 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9571 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9573 if (entry
!= NULL
) break;
9575 // in non-wildcard mode do some additional checks:
9579 // in case we have an alias-name
9581 if (alias_name
!= NULL
)
9583 s
.device_name
= alias_name
;
9585 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9587 if (entry
!= NULL
) break;
9590 // or by device type
9592 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9594 s
.device_name
= "DEVICE_TYPE_CPU";
9596 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9598 s
.device_name
= "DEVICE_TYPE_GPU";
9600 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9602 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9605 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9607 if (entry
!= NULL
) break;
9611 // free converted device_name
9613 myfree (device_name_nospace
);
9622 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9624 u8 tmp
[256] = { 0 };
9626 if (salt_len
> sizeof (tmp
))
9631 memcpy (tmp
, in
, salt_len
);
9633 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9635 if ((salt_len
% 2) == 0)
9637 u32 new_salt_len
= salt_len
/ 2;
9639 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9644 tmp
[i
] = hex_convert (p1
) << 0;
9645 tmp
[i
] |= hex_convert (p0
) << 4;
9648 salt_len
= new_salt_len
;
9655 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9657 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9660 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9662 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9666 u32
*tmp_uint
= (u32
*) tmp
;
9668 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9669 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9670 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9671 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9672 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9673 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9674 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9675 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9676 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9677 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9679 salt_len
= salt_len
* 2;
9687 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9689 lowercase (tmp
, salt_len
);
9692 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9694 uppercase (tmp
, salt_len
);
9699 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9704 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9709 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9711 u32
*tmp_uint
= (uint
*) tmp
;
9717 for (u32 i
= 0; i
< max
; i
++)
9719 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9722 // Important: we may need to increase the length of memcpy since
9723 // we don't want to "loose" some swapped bytes (could happen if
9724 // they do not perfectly fit in the 4-byte blocks)
9725 // Memcpy does always copy the bytes in the BE order, but since
9726 // we swapped them, some important bytes could be in positions
9727 // we normally skip with the original len
9729 if (len
% 4) len
+= 4 - (len
% 4);
9732 memcpy (out
, tmp
, len
);
9737 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9739 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9741 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9743 u32
*digest
= (u32
*) hash_buf
->digest
;
9745 salt_t
*salt
= hash_buf
->salt
;
9747 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9749 char *iter_pos
= input_buf
+ 4;
9751 salt
->salt_iter
= 1 << atoi (iter_pos
);
9753 char *salt_pos
= strchr (iter_pos
, '$');
9755 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9761 salt
->salt_len
= salt_len
;
9763 u8 tmp_buf
[100] = { 0 };
9765 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9767 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9769 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9771 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9772 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9773 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9774 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9776 char *hash_pos
= salt_pos
+ 22;
9778 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9780 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9782 memcpy (digest
, tmp_buf
, 24);
9784 digest
[0] = byte_swap_32 (digest
[0]);
9785 digest
[1] = byte_swap_32 (digest
[1]);
9786 digest
[2] = byte_swap_32 (digest
[2]);
9787 digest
[3] = byte_swap_32 (digest
[3]);
9788 digest
[4] = byte_swap_32 (digest
[4]);
9789 digest
[5] = byte_swap_32 (digest
[5]);
9791 digest
[5] &= ~0xff; // its just 23 not 24 !
9796 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9798 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9800 u32
*digest
= (u32
*) hash_buf
->digest
;
9802 u8 tmp_buf
[100] = { 0 };
9804 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9806 memcpy (digest
, tmp_buf
, 32);
9808 digest
[0] = byte_swap_32 (digest
[0]);
9809 digest
[1] = byte_swap_32 (digest
[1]);
9810 digest
[2] = byte_swap_32 (digest
[2]);
9811 digest
[3] = byte_swap_32 (digest
[3]);
9812 digest
[4] = byte_swap_32 (digest
[4]);
9813 digest
[5] = byte_swap_32 (digest
[5]);
9814 digest
[6] = byte_swap_32 (digest
[6]);
9815 digest
[7] = byte_swap_32 (digest
[7]);
9817 digest
[0] -= SHA256M_A
;
9818 digest
[1] -= SHA256M_B
;
9819 digest
[2] -= SHA256M_C
;
9820 digest
[3] -= SHA256M_D
;
9821 digest
[4] -= SHA256M_E
;
9822 digest
[5] -= SHA256M_F
;
9823 digest
[6] -= SHA256M_G
;
9824 digest
[7] -= SHA256M_H
;
9829 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9831 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9833 u32
*digest
= (u32
*) hash_buf
->digest
;
9835 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9836 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9838 digest
[0] = byte_swap_32 (digest
[0]);
9839 digest
[1] = byte_swap_32 (digest
[1]);
9843 IP (digest
[0], digest
[1], tt
);
9845 digest
[0] = digest
[0];
9846 digest
[1] = digest
[1];
9853 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9855 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9857 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9859 u32
*digest
= (u32
*) hash_buf
->digest
;
9861 salt_t
*salt
= hash_buf
->salt
;
9863 char *hash_pos
= input_buf
+ 10;
9865 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9866 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9867 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9868 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9869 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9871 digest
[0] -= SHA1M_A
;
9872 digest
[1] -= SHA1M_B
;
9873 digest
[2] -= SHA1M_C
;
9874 digest
[3] -= SHA1M_D
;
9875 digest
[4] -= SHA1M_E
;
9879 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9881 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9883 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9885 salt
->salt_len
= salt_len
;
9890 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9892 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9894 u32
*digest
= (u32
*) hash_buf
->digest
;
9896 salt_t
*salt
= hash_buf
->salt
;
9898 char *hash_pos
= input_buf
+ 8;
9900 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9901 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9902 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9903 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9904 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9906 digest
[0] -= SHA1M_A
;
9907 digest
[1] -= SHA1M_B
;
9908 digest
[2] -= SHA1M_C
;
9909 digest
[3] -= SHA1M_D
;
9910 digest
[4] -= SHA1M_E
;
9914 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9916 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9918 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9920 salt
->salt_len
= salt_len
;
9925 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9927 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9929 u64
*digest
= (u64
*) hash_buf
->digest
;
9931 salt_t
*salt
= hash_buf
->salt
;
9933 char *hash_pos
= input_buf
+ 8;
9935 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9936 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9937 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9938 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9939 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9940 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9941 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9942 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9944 digest
[0] -= SHA512M_A
;
9945 digest
[1] -= SHA512M_B
;
9946 digest
[2] -= SHA512M_C
;
9947 digest
[3] -= SHA512M_D
;
9948 digest
[4] -= SHA512M_E
;
9949 digest
[5] -= SHA512M_F
;
9950 digest
[6] -= SHA512M_G
;
9951 digest
[7] -= SHA512M_H
;
9955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9957 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9959 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9961 salt
->salt_len
= salt_len
;
9966 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9968 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9970 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9974 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9977 u32
*digest
= (u32
*) hash_buf
->digest
;
9979 salt_t
*salt
= hash_buf
->salt
;
9981 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9982 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9983 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9984 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9986 digest
[0] = byte_swap_32 (digest
[0]);
9987 digest
[1] = byte_swap_32 (digest
[1]);
9988 digest
[2] = byte_swap_32 (digest
[2]);
9989 digest
[3] = byte_swap_32 (digest
[3]);
9991 digest
[0] -= MD5M_A
;
9992 digest
[1] -= MD5M_B
;
9993 digest
[2] -= MD5M_C
;
9994 digest
[3] -= MD5M_D
;
9996 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9998 uint salt_len
= input_len
- 32 - 1;
10000 char *salt_buf
= input_buf
+ 32 + 1;
10002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10004 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10006 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10008 salt
->salt_len
= salt_len
;
10010 return (PARSER_OK
);
10013 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10015 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10017 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10021 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10026 char clean_input_buf
[32] = { 0 };
10028 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10029 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10031 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10035 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10041 clean_input_buf
[k
] = input_buf
[i
];
10049 u32
*digest
= (u32
*) hash_buf
->digest
;
10051 salt_t
*salt
= hash_buf
->salt
;
10053 u32 a
, b
, c
, d
, e
, f
;
10055 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10056 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10057 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10058 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10059 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10060 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10062 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10063 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10065 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10066 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10067 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10068 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10069 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10070 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10072 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10073 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10075 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10076 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10077 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10078 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10079 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10080 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10082 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10083 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10085 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10086 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10087 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10088 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10089 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10090 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10092 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10093 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10095 digest
[0] = byte_swap_32 (digest
[0]);
10096 digest
[1] = byte_swap_32 (digest
[1]);
10097 digest
[2] = byte_swap_32 (digest
[2]);
10098 digest
[3] = byte_swap_32 (digest
[3]);
10100 digest
[0] -= MD5M_A
;
10101 digest
[1] -= MD5M_B
;
10102 digest
[2] -= MD5M_C
;
10103 digest
[3] -= MD5M_D
;
10105 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10107 uint salt_len
= input_len
- 30 - 1;
10109 char *salt_buf
= input_buf
+ 30 + 1;
10111 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10113 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10115 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10116 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10118 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10120 salt
->salt_len
= salt_len
;
10122 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10124 salt
->salt_len
+= 22;
10126 return (PARSER_OK
);
10129 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10131 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10133 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10137 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10140 u32
*digest
= (u32
*) hash_buf
->digest
;
10142 salt_t
*salt
= hash_buf
->salt
;
10144 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10145 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10146 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10147 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10148 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10150 digest
[0] -= SHA1M_A
;
10151 digest
[1] -= SHA1M_B
;
10152 digest
[2] -= SHA1M_C
;
10153 digest
[3] -= SHA1M_D
;
10154 digest
[4] -= SHA1M_E
;
10156 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10158 uint salt_len
= input_len
- 40 - 1;
10160 char *salt_buf
= input_buf
+ 40 + 1;
10162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10164 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10166 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10168 salt
->salt_len
= salt_len
;
10170 return (PARSER_OK
);
10173 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10175 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10177 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10181 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10184 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10186 char *iter_pos
= input_buf
+ 6;
10188 salt_t
*salt
= hash_buf
->salt
;
10190 uint iter
= atoi (iter_pos
);
10194 iter
= ROUNDS_DCC2
;
10197 salt
->salt_iter
= iter
- 1;
10199 char *salt_pos
= strchr (iter_pos
, '#');
10201 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10205 char *digest_pos
= strchr (salt_pos
, '#');
10207 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10211 uint salt_len
= digest_pos
- salt_pos
- 1;
10213 u32
*digest
= (u32
*) hash_buf
->digest
;
10215 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10216 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10217 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10218 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10226 salt
->salt_len
= salt_len
;
10228 return (PARSER_OK
);
10231 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10233 u32
*digest
= (u32
*) hash_buf
->digest
;
10235 salt_t
*salt
= hash_buf
->salt
;
10237 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10241 memcpy (&in
, input_buf
, input_len
);
10243 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10245 memcpy (digest
, in
.keymic
, 16);
10248 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10249 The phrase "Pairwise key expansion"
10250 Access Point Address (referred to as Authenticator Address AA)
10251 Supplicant Address (referred to as Supplicant Address SA)
10252 Access Point Nonce (referred to as Authenticator Anonce)
10253 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10256 uint salt_len
= strlen (in
.essid
);
10260 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10262 return (PARSER_SALT_LENGTH
);
10265 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10267 salt
->salt_len
= salt_len
;
10269 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10271 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10273 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10275 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10277 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10278 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10282 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10283 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10286 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10288 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10289 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10293 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10294 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10297 for (int i
= 0; i
< 25; i
++)
10299 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10302 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10303 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10304 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10305 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10307 wpa
->keyver
= in
.keyver
;
10309 if (wpa
->keyver
> 255)
10311 log_info ("ATTENTION!");
10312 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10313 log_info (" This could be due to a recent aircrack-ng bug.");
10314 log_info (" The key version was automatically reset to a reasonable value.");
10317 wpa
->keyver
&= 0xff;
10320 wpa
->eapol_size
= in
.eapol_size
;
10322 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10324 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10326 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10328 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10330 if (wpa
->keyver
== 1)
10336 digest
[0] = byte_swap_32 (digest
[0]);
10337 digest
[1] = byte_swap_32 (digest
[1]);
10338 digest
[2] = byte_swap_32 (digest
[2]);
10339 digest
[3] = byte_swap_32 (digest
[3]);
10341 for (int i
= 0; i
< 64; i
++)
10343 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10347 uint32_t *p0
= (uint32_t *) in
.essid
;
10351 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10352 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10354 salt
->salt_buf
[10] = c0
;
10355 salt
->salt_buf
[11] = c1
;
10357 return (PARSER_OK
);
10360 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10362 u32
*digest
= (u32
*) hash_buf
->digest
;
10364 salt_t
*salt
= hash_buf
->salt
;
10366 if (input_len
== 0)
10368 log_error ("Password Safe v2 container not specified");
10373 FILE *fp
= fopen (input_buf
, "rb");
10377 log_error ("%s: %s", input_buf
, strerror (errno
));
10384 memset (&buf
, 0, sizeof (psafe2_hdr
));
10386 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10390 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10392 salt
->salt_buf
[0] = buf
.random
[0];
10393 salt
->salt_buf
[1] = buf
.random
[1];
10395 salt
->salt_len
= 8;
10396 salt
->salt_iter
= 1000;
10398 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10399 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10400 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10401 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10402 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10404 return (PARSER_OK
);
10407 int psafe3_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 if (input_len
== 0)
10415 log_error (".psafe3 not specified");
10420 FILE *fp
= fopen (input_buf
, "rb");
10424 log_error ("%s: %s", input_buf
, strerror (errno
));
10431 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10435 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10437 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10439 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10441 salt
->salt_iter
= in
.iterations
+ 1;
10443 salt
->salt_buf
[0] = in
.salt_buf
[0];
10444 salt
->salt_buf
[1] = in
.salt_buf
[1];
10445 salt
->salt_buf
[2] = in
.salt_buf
[2];
10446 salt
->salt_buf
[3] = in
.salt_buf
[3];
10447 salt
->salt_buf
[4] = in
.salt_buf
[4];
10448 salt
->salt_buf
[5] = in
.salt_buf
[5];
10449 salt
->salt_buf
[6] = in
.salt_buf
[6];
10450 salt
->salt_buf
[7] = in
.salt_buf
[7];
10452 salt
->salt_len
= 32;
10454 digest
[0] = in
.hash_buf
[0];
10455 digest
[1] = in
.hash_buf
[1];
10456 digest
[2] = in
.hash_buf
[2];
10457 digest
[3] = in
.hash_buf
[3];
10458 digest
[4] = in
.hash_buf
[4];
10459 digest
[5] = in
.hash_buf
[5];
10460 digest
[6] = in
.hash_buf
[6];
10461 digest
[7] = in
.hash_buf
[7];
10463 digest
[0] = byte_swap_32 (digest
[0]);
10464 digest
[1] = byte_swap_32 (digest
[1]);
10465 digest
[2] = byte_swap_32 (digest
[2]);
10466 digest
[3] = byte_swap_32 (digest
[3]);
10467 digest
[4] = byte_swap_32 (digest
[4]);
10468 digest
[5] = byte_swap_32 (digest
[5]);
10469 digest
[6] = byte_swap_32 (digest
[6]);
10470 digest
[7] = byte_swap_32 (digest
[7]);
10472 return (PARSER_OK
);
10475 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10477 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10479 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10481 u32
*digest
= (u32
*) hash_buf
->digest
;
10483 salt_t
*salt
= hash_buf
->salt
;
10485 char *iter_pos
= input_buf
+ 3;
10487 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10489 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10491 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10493 salt
->salt_iter
= salt_iter
;
10495 char *salt_pos
= iter_pos
+ 1;
10499 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10501 salt
->salt_len
= salt_len
;
10503 char *hash_pos
= salt_pos
+ salt_len
;
10505 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10507 return (PARSER_OK
);
10510 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10512 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10514 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10516 u32
*digest
= (u32
*) hash_buf
->digest
;
10518 salt_t
*salt
= hash_buf
->salt
;
10520 char *salt_pos
= input_buf
+ 3;
10522 uint iterations_len
= 0;
10524 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10528 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10530 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10531 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10535 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10539 iterations_len
+= 8;
10543 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10546 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10548 char *hash_pos
= strchr (salt_pos
, '$');
10550 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10552 uint salt_len
= hash_pos
- salt_pos
;
10554 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10556 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10558 salt
->salt_len
= salt_len
;
10562 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10564 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10566 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10568 return (PARSER_OK
);
10571 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10573 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10575 u32
*digest
= (u32
*) hash_buf
->digest
;
10577 salt_t
*salt
= hash_buf
->salt
;
10579 char *salt_pos
= input_buf
+ 6;
10581 uint iterations_len
= 0;
10583 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10587 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10589 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10590 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10594 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10598 iterations_len
+= 8;
10602 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10605 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10607 char *hash_pos
= strchr (salt_pos
, '$');
10609 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10611 uint salt_len
= hash_pos
- salt_pos
;
10613 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10615 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10617 salt
->salt_len
= salt_len
;
10621 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10623 return (PARSER_OK
);
10626 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10628 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10630 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10632 u32
*digest
= (u32
*) hash_buf
->digest
;
10634 salt_t
*salt
= hash_buf
->salt
;
10636 char *salt_pos
= input_buf
+ 14;
10638 char *hash_pos
= strchr (salt_pos
, '*');
10640 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10644 uint salt_len
= hash_pos
- salt_pos
- 1;
10646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10652 salt
->salt_len
= salt_len
;
10654 u8 tmp_buf
[100] = { 0 };
10656 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10658 memcpy (digest
, tmp_buf
, 20);
10660 digest
[0] = byte_swap_32 (digest
[0]);
10661 digest
[1] = byte_swap_32 (digest
[1]);
10662 digest
[2] = byte_swap_32 (digest
[2]);
10663 digest
[3] = byte_swap_32 (digest
[3]);
10664 digest
[4] = byte_swap_32 (digest
[4]);
10666 digest
[0] -= SHA1M_A
;
10667 digest
[1] -= SHA1M_B
;
10668 digest
[2] -= SHA1M_C
;
10669 digest
[3] -= SHA1M_D
;
10670 digest
[4] -= SHA1M_E
;
10672 return (PARSER_OK
);
10675 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10677 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10679 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10681 if (c12
& 3) return (PARSER_HASH_VALUE
);
10683 u32
*digest
= (u32
*) hash_buf
->digest
;
10685 salt_t
*salt
= hash_buf
->salt
;
10687 // for ascii_digest
10688 salt
->salt_sign
[0] = input_buf
[0];
10689 salt
->salt_sign
[1] = input_buf
[1];
10691 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10692 | itoa64_to_int (input_buf
[1]) << 6;
10694 salt
->salt_len
= 2;
10696 u8 tmp_buf
[100] = { 0 };
10698 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10700 memcpy (digest
, tmp_buf
, 8);
10704 IP (digest
[0], digest
[1], tt
);
10709 return (PARSER_OK
);
10712 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10714 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10716 u32
*digest
= (u32
*) hash_buf
->digest
;
10718 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10719 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10720 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10721 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10723 digest
[0] = byte_swap_32 (digest
[0]);
10724 digest
[1] = byte_swap_32 (digest
[1]);
10725 digest
[2] = byte_swap_32 (digest
[2]);
10726 digest
[3] = byte_swap_32 (digest
[3]);
10728 digest
[0] -= MD4M_A
;
10729 digest
[1] -= MD4M_B
;
10730 digest
[2] -= MD4M_C
;
10731 digest
[3] -= MD4M_D
;
10733 return (PARSER_OK
);
10736 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10738 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10740 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10744 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10747 u32
*digest
= (u32
*) hash_buf
->digest
;
10749 salt_t
*salt
= hash_buf
->salt
;
10751 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10752 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10753 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10754 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10756 digest
[0] = byte_swap_32 (digest
[0]);
10757 digest
[1] = byte_swap_32 (digest
[1]);
10758 digest
[2] = byte_swap_32 (digest
[2]);
10759 digest
[3] = byte_swap_32 (digest
[3]);
10761 digest
[0] -= MD4M_A
;
10762 digest
[1] -= MD4M_B
;
10763 digest
[2] -= MD4M_C
;
10764 digest
[3] -= MD4M_D
;
10766 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10768 uint salt_len
= input_len
- 32 - 1;
10770 char *salt_buf
= input_buf
+ 32 + 1;
10772 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10774 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10776 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10778 salt
->salt_len
= salt_len
;
10780 return (PARSER_OK
);
10783 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10785 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10787 u32
*digest
= (u32
*) hash_buf
->digest
;
10789 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10790 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10791 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10792 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10794 digest
[0] = byte_swap_32 (digest
[0]);
10795 digest
[1] = byte_swap_32 (digest
[1]);
10796 digest
[2] = byte_swap_32 (digest
[2]);
10797 digest
[3] = byte_swap_32 (digest
[3]);
10799 digest
[0] -= MD5M_A
;
10800 digest
[1] -= MD5M_B
;
10801 digest
[2] -= MD5M_C
;
10802 digest
[3] -= MD5M_D
;
10804 return (PARSER_OK
);
10807 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10809 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10811 u32
*digest
= (u32
*) hash_buf
->digest
;
10813 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10814 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10818 digest
[0] = byte_swap_32 (digest
[0]);
10819 digest
[1] = byte_swap_32 (digest
[1]);
10821 return (PARSER_OK
);
10824 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10826 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10828 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10832 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10835 u32
*digest
= (u32
*) hash_buf
->digest
;
10837 salt_t
*salt
= hash_buf
->salt
;
10839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10841 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10842 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10844 digest
[0] = byte_swap_32 (digest
[0]);
10845 digest
[1] = byte_swap_32 (digest
[1]);
10846 digest
[2] = byte_swap_32 (digest
[2]);
10847 digest
[3] = byte_swap_32 (digest
[3]);
10849 digest
[0] -= MD5M_A
;
10850 digest
[1] -= MD5M_B
;
10851 digest
[2] -= MD5M_C
;
10852 digest
[3] -= MD5M_D
;
10854 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10856 uint salt_len
= input_len
- 32 - 1;
10858 char *salt_buf
= input_buf
+ 32 + 1;
10860 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10862 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10864 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10866 salt
->salt_len
= salt_len
;
10868 return (PARSER_OK
);
10871 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10873 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10875 u32
*digest
= (u32
*) hash_buf
->digest
;
10877 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10878 | itoa64_to_int (input_buf
[ 1]) << 6
10879 | itoa64_to_int (input_buf
[ 2]) << 12
10880 | itoa64_to_int (input_buf
[ 3]) << 18;
10881 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10882 | itoa64_to_int (input_buf
[ 5]) << 6
10883 | itoa64_to_int (input_buf
[ 6]) << 12
10884 | itoa64_to_int (input_buf
[ 7]) << 18;
10885 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10886 | itoa64_to_int (input_buf
[ 9]) << 6
10887 | itoa64_to_int (input_buf
[10]) << 12
10888 | itoa64_to_int (input_buf
[11]) << 18;
10889 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10890 | itoa64_to_int (input_buf
[13]) << 6
10891 | itoa64_to_int (input_buf
[14]) << 12
10892 | itoa64_to_int (input_buf
[15]) << 18;
10894 digest
[0] -= MD5M_A
;
10895 digest
[1] -= MD5M_B
;
10896 digest
[2] -= MD5M_C
;
10897 digest
[3] -= MD5M_D
;
10899 digest
[0] &= 0x00ffffff;
10900 digest
[1] &= 0x00ffffff;
10901 digest
[2] &= 0x00ffffff;
10902 digest
[3] &= 0x00ffffff;
10904 return (PARSER_OK
);
10907 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10909 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10911 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10915 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10918 u32
*digest
= (u32
*) hash_buf
->digest
;
10920 salt_t
*salt
= hash_buf
->salt
;
10922 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10923 | itoa64_to_int (input_buf
[ 1]) << 6
10924 | itoa64_to_int (input_buf
[ 2]) << 12
10925 | itoa64_to_int (input_buf
[ 3]) << 18;
10926 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10927 | itoa64_to_int (input_buf
[ 5]) << 6
10928 | itoa64_to_int (input_buf
[ 6]) << 12
10929 | itoa64_to_int (input_buf
[ 7]) << 18;
10930 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10931 | itoa64_to_int (input_buf
[ 9]) << 6
10932 | itoa64_to_int (input_buf
[10]) << 12
10933 | itoa64_to_int (input_buf
[11]) << 18;
10934 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10935 | itoa64_to_int (input_buf
[13]) << 6
10936 | itoa64_to_int (input_buf
[14]) << 12
10937 | itoa64_to_int (input_buf
[15]) << 18;
10939 digest
[0] -= MD5M_A
;
10940 digest
[1] -= MD5M_B
;
10941 digest
[2] -= MD5M_C
;
10942 digest
[3] -= MD5M_D
;
10944 digest
[0] &= 0x00ffffff;
10945 digest
[1] &= 0x00ffffff;
10946 digest
[2] &= 0x00ffffff;
10947 digest
[3] &= 0x00ffffff;
10949 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10951 uint salt_len
= input_len
- 16 - 1;
10953 char *salt_buf
= input_buf
+ 16 + 1;
10955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10957 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10959 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10961 salt
->salt_len
= salt_len
;
10963 return (PARSER_OK
);
10966 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10968 key
[0] = (nthash
[0] >> 0);
10969 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10970 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10971 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10972 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10973 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10974 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10975 key
[7] = (nthash
[6] << 1);
10987 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10989 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10991 u32
*digest
= (u32
*) hash_buf
->digest
;
10993 salt_t
*salt
= hash_buf
->salt
;
10995 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11001 char *user_pos
= input_buf
;
11003 char *unused_pos
= strchr (user_pos
, ':');
11005 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11007 uint user_len
= unused_pos
- user_pos
;
11009 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11013 char *domain_pos
= strchr (unused_pos
, ':');
11015 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11017 uint unused_len
= domain_pos
- unused_pos
;
11019 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11023 char *srvchall_pos
= strchr (domain_pos
, ':');
11025 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11027 uint domain_len
= srvchall_pos
- domain_pos
;
11029 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11033 char *hash_pos
= strchr (srvchall_pos
, ':');
11035 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11037 uint srvchall_len
= hash_pos
- srvchall_pos
;
11039 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11043 char *clichall_pos
= strchr (hash_pos
, ':');
11045 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11047 uint hash_len
= clichall_pos
- hash_pos
;
11049 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11053 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11055 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11058 * store some data for later use
11061 netntlm
->user_len
= user_len
* 2;
11062 netntlm
->domain_len
= domain_len
* 2;
11063 netntlm
->srvchall_len
= srvchall_len
/ 2;
11064 netntlm
->clichall_len
= clichall_len
/ 2;
11066 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11067 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11070 * handle username and domainname
11073 for (uint i
= 0; i
< user_len
; i
++)
11075 *userdomain_ptr
++ = user_pos
[i
];
11076 *userdomain_ptr
++ = 0;
11079 for (uint i
= 0; i
< domain_len
; i
++)
11081 *userdomain_ptr
++ = domain_pos
[i
];
11082 *userdomain_ptr
++ = 0;
11086 * handle server challenge encoding
11089 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11091 const char p0
= srvchall_pos
[i
+ 0];
11092 const char p1
= srvchall_pos
[i
+ 1];
11094 *chall_ptr
++ = hex_convert (p1
) << 0
11095 | hex_convert (p0
) << 4;
11099 * handle client challenge encoding
11102 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11104 const char p0
= clichall_pos
[i
+ 0];
11105 const char p1
= clichall_pos
[i
+ 1];
11107 *chall_ptr
++ = hex_convert (p1
) << 0
11108 | hex_convert (p0
) << 4;
11115 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11117 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11121 salt
->salt_len
= salt_len
;
11123 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11124 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11125 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11126 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11128 digest
[0] = byte_swap_32 (digest
[0]);
11129 digest
[1] = byte_swap_32 (digest
[1]);
11130 digest
[2] = byte_swap_32 (digest
[2]);
11131 digest
[3] = byte_swap_32 (digest
[3]);
11133 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11135 uint digest_tmp
[2] = { 0 };
11137 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11138 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11140 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11141 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11143 /* special case 2: ESS */
11145 if (srvchall_len
== 48)
11147 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11149 uint w
[16] = { 0 };
11151 w
[ 0] = netntlm
->chall_buf
[6];
11152 w
[ 1] = netntlm
->chall_buf
[7];
11153 w
[ 2] = netntlm
->chall_buf
[0];
11154 w
[ 3] = netntlm
->chall_buf
[1];
11158 uint dgst
[4] = { 0 };
11167 salt
->salt_buf
[0] = dgst
[0];
11168 salt
->salt_buf
[1] = dgst
[1];
11172 /* precompute netntlmv1 exploit start */
11174 for (uint i
= 0; i
< 0x10000; i
++)
11176 uint key_md4
[2] = { i
, 0 };
11177 uint key_des
[2] = { 0, 0 };
11179 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11181 uint Kc
[16] = { 0 };
11182 uint Kd
[16] = { 0 };
11184 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11186 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11188 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11190 if (data3
[0] != digest_tmp
[0]) continue;
11191 if (data3
[1] != digest_tmp
[1]) continue;
11193 salt
->salt_buf
[2] = i
;
11195 salt
->salt_len
= 24;
11200 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11201 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11203 /* precompute netntlmv1 exploit stop */
11207 IP (digest
[0], digest
[1], tt
);
11208 IP (digest
[2], digest
[3], tt
);
11210 digest
[0] = rotr32 (digest
[0], 29);
11211 digest
[1] = rotr32 (digest
[1], 29);
11212 digest
[2] = rotr32 (digest
[2], 29);
11213 digest
[3] = rotr32 (digest
[3], 29);
11215 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11217 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11218 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11220 return (PARSER_OK
);
11223 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11225 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11227 u32
*digest
= (u32
*) hash_buf
->digest
;
11229 salt_t
*salt
= hash_buf
->salt
;
11231 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11237 char *user_pos
= input_buf
;
11239 char *unused_pos
= strchr (user_pos
, ':');
11241 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11243 uint user_len
= unused_pos
- user_pos
;
11245 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11249 char *domain_pos
= strchr (unused_pos
, ':');
11251 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11253 uint unused_len
= domain_pos
- unused_pos
;
11255 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11259 char *srvchall_pos
= strchr (domain_pos
, ':');
11261 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11263 uint domain_len
= srvchall_pos
- domain_pos
;
11265 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11269 char *hash_pos
= strchr (srvchall_pos
, ':');
11271 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11273 uint srvchall_len
= hash_pos
- srvchall_pos
;
11275 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11279 char *clichall_pos
= strchr (hash_pos
, ':');
11281 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11283 uint hash_len
= clichall_pos
- hash_pos
;
11285 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11289 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11291 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11293 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11296 * store some data for later use
11299 netntlm
->user_len
= user_len
* 2;
11300 netntlm
->domain_len
= domain_len
* 2;
11301 netntlm
->srvchall_len
= srvchall_len
/ 2;
11302 netntlm
->clichall_len
= clichall_len
/ 2;
11304 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11305 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11308 * handle username and domainname
11311 for (uint i
= 0; i
< user_len
; i
++)
11313 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11314 *userdomain_ptr
++ = 0;
11317 for (uint i
= 0; i
< domain_len
; i
++)
11319 *userdomain_ptr
++ = domain_pos
[i
];
11320 *userdomain_ptr
++ = 0;
11323 *userdomain_ptr
++ = 0x80;
11326 * handle server challenge encoding
11329 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11331 const char p0
= srvchall_pos
[i
+ 0];
11332 const char p1
= srvchall_pos
[i
+ 1];
11334 *chall_ptr
++ = hex_convert (p1
) << 0
11335 | hex_convert (p0
) << 4;
11339 * handle client challenge encoding
11342 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11344 const char p0
= clichall_pos
[i
+ 0];
11345 const char p1
= clichall_pos
[i
+ 1];
11347 *chall_ptr
++ = hex_convert (p1
) << 0
11348 | hex_convert (p0
) << 4;
11351 *chall_ptr
++ = 0x80;
11354 * handle hash itself
11357 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11358 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11359 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11360 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11362 digest
[0] = byte_swap_32 (digest
[0]);
11363 digest
[1] = byte_swap_32 (digest
[1]);
11364 digest
[2] = byte_swap_32 (digest
[2]);
11365 digest
[3] = byte_swap_32 (digest
[3]);
11368 * reuse challange data as salt_buf, its the buffer that is most likely unique
11371 salt
->salt_buf
[0] = 0;
11372 salt
->salt_buf
[1] = 0;
11373 salt
->salt_buf
[2] = 0;
11374 salt
->salt_buf
[3] = 0;
11375 salt
->salt_buf
[4] = 0;
11376 salt
->salt_buf
[5] = 0;
11377 salt
->salt_buf
[6] = 0;
11378 salt
->salt_buf
[7] = 0;
11382 uptr
= (uint
*) netntlm
->userdomain_buf
;
11384 for (uint i
= 0; i
< 16; i
+= 16)
11386 md5_64 (uptr
, salt
->salt_buf
);
11389 uptr
= (uint
*) netntlm
->chall_buf
;
11391 for (uint i
= 0; i
< 256; i
+= 16)
11393 md5_64 (uptr
, salt
->salt_buf
);
11396 salt
->salt_len
= 16;
11398 return (PARSER_OK
);
11401 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11403 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11405 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11409 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11412 u32
*digest
= (u32
*) hash_buf
->digest
;
11414 salt_t
*salt
= hash_buf
->salt
;
11416 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11417 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11418 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11419 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11421 digest
[0] = byte_swap_32 (digest
[0]);
11422 digest
[1] = byte_swap_32 (digest
[1]);
11423 digest
[2] = byte_swap_32 (digest
[2]);
11424 digest
[3] = byte_swap_32 (digest
[3]);
11426 digest
[0] -= MD5M_A
;
11427 digest
[1] -= MD5M_B
;
11428 digest
[2] -= MD5M_C
;
11429 digest
[3] -= MD5M_D
;
11431 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11433 uint salt_len
= input_len
- 32 - 1;
11435 char *salt_buf
= input_buf
+ 32 + 1;
11437 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11439 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11441 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11443 salt
->salt_len
= salt_len
;
11445 return (PARSER_OK
);
11448 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11450 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11452 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11456 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11459 u32
*digest
= (u32
*) hash_buf
->digest
;
11461 salt_t
*salt
= hash_buf
->salt
;
11463 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11464 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11465 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11466 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11468 digest
[0] = byte_swap_32 (digest
[0]);
11469 digest
[1] = byte_swap_32 (digest
[1]);
11470 digest
[2] = byte_swap_32 (digest
[2]);
11471 digest
[3] = byte_swap_32 (digest
[3]);
11473 digest
[0] -= MD5M_A
;
11474 digest
[1] -= MD5M_B
;
11475 digest
[2] -= MD5M_C
;
11476 digest
[3] -= MD5M_D
;
11478 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11480 uint salt_len
= input_len
- 32 - 1;
11482 char *salt_buf
= input_buf
+ 32 + 1;
11484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11490 salt
->salt_len
= salt_len
;
11492 return (PARSER_OK
);
11495 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11497 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11499 u32
*digest
= (u32
*) hash_buf
->digest
;
11501 salt_t
*salt
= hash_buf
->salt
;
11503 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11504 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11505 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11506 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11508 digest
[0] = byte_swap_32 (digest
[0]);
11509 digest
[1] = byte_swap_32 (digest
[1]);
11510 digest
[2] = byte_swap_32 (digest
[2]);
11511 digest
[3] = byte_swap_32 (digest
[3]);
11513 digest
[0] -= MD5M_A
;
11514 digest
[1] -= MD5M_B
;
11515 digest
[2] -= MD5M_C
;
11516 digest
[3] -= MD5M_D
;
11519 * This is a virtual salt. While the algorithm is basically not salted
11520 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11521 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11524 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11526 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11528 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11530 salt
->salt_len
= salt_len
;
11532 return (PARSER_OK
);
11535 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11537 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11539 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11543 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11546 u32
*digest
= (u32
*) hash_buf
->digest
;
11548 salt_t
*salt
= hash_buf
->salt
;
11550 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11551 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11552 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11553 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11555 digest
[0] = byte_swap_32 (digest
[0]);
11556 digest
[1] = byte_swap_32 (digest
[1]);
11557 digest
[2] = byte_swap_32 (digest
[2]);
11558 digest
[3] = byte_swap_32 (digest
[3]);
11560 digest
[0] -= MD5M_A
;
11561 digest
[1] -= MD5M_B
;
11562 digest
[2] -= MD5M_C
;
11563 digest
[3] -= MD5M_D
;
11565 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11567 uint salt_len
= input_len
- 32 - 1;
11569 char *salt_buf
= input_buf
+ 32 + 1;
11571 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11573 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11577 salt
->salt_len
= salt_len
;
11579 return (PARSER_OK
);
11582 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11584 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11586 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11590 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11593 u32
*digest
= (u32
*) hash_buf
->digest
;
11595 salt_t
*salt
= hash_buf
->salt
;
11597 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11598 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11599 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11600 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11602 digest
[0] = byte_swap_32 (digest
[0]);
11603 digest
[1] = byte_swap_32 (digest
[1]);
11604 digest
[2] = byte_swap_32 (digest
[2]);
11605 digest
[3] = byte_swap_32 (digest
[3]);
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 dcc_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_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11632 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) 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] -= MD4M_A
;
11650 digest
[1] -= MD4M_B
;
11651 digest
[2] -= MD4M_C
;
11652 digest
[3] -= MD4M_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 ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11675 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11679 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11682 u32
*digest
= (u32
*) hash_buf
->digest
;
11684 salt_t
*salt
= hash_buf
->salt
;
11686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11691 digest
[0] = byte_swap_32 (digest
[0]);
11692 digest
[1] = byte_swap_32 (digest
[1]);
11693 digest
[2] = byte_swap_32 (digest
[2]);
11694 digest
[3] = byte_swap_32 (digest
[3]);
11696 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11698 uint salt_len
= input_len
- 32 - 1;
11700 char *salt_buf
= input_buf
+ 32 + 1;
11702 uint salt_pc_block
[16] = { 0 };
11704 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11706 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11708 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11710 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11712 salt_pc_block
[14] = salt_len
* 8;
11714 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11716 md5_64 (salt_pc_block
, salt_pc_digest
);
11718 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11719 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11720 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11721 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11723 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11725 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11727 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11729 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11730 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11731 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11732 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11734 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11736 return (PARSER_OK
);
11739 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11741 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11743 u32
*digest
= (u32
*) hash_buf
->digest
;
11745 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11746 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11747 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11748 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11749 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11751 digest
[0] -= SHA1M_A
;
11752 digest
[1] -= SHA1M_B
;
11753 digest
[2] -= SHA1M_C
;
11754 digest
[3] -= SHA1M_D
;
11755 digest
[4] -= SHA1M_E
;
11757 return (PARSER_OK
);
11760 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11762 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11764 u32
*digest
= (u32
*) hash_buf
->digest
;
11766 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11767 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11768 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11769 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11770 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11772 return (PARSER_OK
);
11775 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11777 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11779 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11781 u32
*digest
= (u32
*) hash_buf
->digest
;
11785 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11786 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11787 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11788 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11789 digest
[4] = 0x00000000;
11791 return (PARSER_OK
);
11794 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11796 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11798 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11802 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11805 u32
*digest
= (u32
*) hash_buf
->digest
;
11807 salt_t
*salt
= hash_buf
->salt
;
11809 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11810 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11811 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11812 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11813 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11815 digest
[0] -= SHA1M_A
;
11816 digest
[1] -= SHA1M_B
;
11817 digest
[2] -= SHA1M_C
;
11818 digest
[3] -= SHA1M_D
;
11819 digest
[4] -= SHA1M_E
;
11821 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11823 uint salt_len
= input_len
- 40 - 1;
11825 char *salt_buf
= input_buf
+ 40 + 1;
11827 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11829 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11831 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11833 salt
->salt_len
= salt_len
;
11835 return (PARSER_OK
);
11838 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11840 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11842 u32
*digest
= (u32
*) hash_buf
->digest
;
11844 salt_t
*salt
= hash_buf
->salt
;
11846 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11848 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11849 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11850 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11851 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11852 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11854 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11856 uint salt_len
= input_len
- 40 - 1;
11858 char *salt_buf
= input_buf
+ 40 + 1;
11860 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11862 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
11864 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
11866 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
11869 pstoken
->salt_len
= salt_len
/ 2;
11871 /* some fake salt for the sorting mechanisms */
11873 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
11874 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
11875 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
11876 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
11877 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
11878 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
11879 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
11880 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
11882 salt
->salt_len
= 32;
11884 /* we need to check if we can precompute some of the data --
11885 this is possible since the scheme is badly designed */
11887 pstoken
->pc_digest
[0] = SHA1M_A
;
11888 pstoken
->pc_digest
[1] = SHA1M_B
;
11889 pstoken
->pc_digest
[2] = SHA1M_C
;
11890 pstoken
->pc_digest
[3] = SHA1M_D
;
11891 pstoken
->pc_digest
[4] = SHA1M_E
;
11893 pstoken
->pc_offset
= 0;
11895 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
11899 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
11900 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
11901 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
11902 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
11903 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
11904 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
11905 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
11906 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
11907 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
11908 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
11909 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
11910 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
11911 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
11912 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
11913 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
11914 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
11916 sha1_64 (w
, pstoken
->pc_digest
);
11918 pstoken
->pc_offset
+= 16;
11921 return (PARSER_OK
);
11924 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11926 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11928 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11930 u32
*digest
= (u32
*) hash_buf
->digest
;
11932 u8 tmp_buf
[100] = { 0 };
11934 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11936 memcpy (digest
, tmp_buf
, 20);
11938 digest
[0] = byte_swap_32 (digest
[0]);
11939 digest
[1] = byte_swap_32 (digest
[1]);
11940 digest
[2] = byte_swap_32 (digest
[2]);
11941 digest
[3] = byte_swap_32 (digest
[3]);
11942 digest
[4] = byte_swap_32 (digest
[4]);
11944 digest
[0] -= SHA1M_A
;
11945 digest
[1] -= SHA1M_B
;
11946 digest
[2] -= SHA1M_C
;
11947 digest
[3] -= SHA1M_D
;
11948 digest
[4] -= SHA1M_E
;
11950 return (PARSER_OK
);
11953 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11955 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11957 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11959 u32
*digest
= (u32
*) hash_buf
->digest
;
11961 salt_t
*salt
= hash_buf
->salt
;
11963 u8 tmp_buf
[100] = { 0 };
11965 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11967 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11969 memcpy (digest
, tmp_buf
, 20);
11971 int salt_len
= tmp_len
- 20;
11973 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11975 salt
->salt_len
= salt_len
;
11977 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11979 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11981 char *ptr
= (char *) salt
->salt_buf
;
11983 ptr
[salt
->salt_len
] = 0x80;
11986 digest
[0] = byte_swap_32 (digest
[0]);
11987 digest
[1] = byte_swap_32 (digest
[1]);
11988 digest
[2] = byte_swap_32 (digest
[2]);
11989 digest
[3] = byte_swap_32 (digest
[3]);
11990 digest
[4] = byte_swap_32 (digest
[4]);
11992 digest
[0] -= SHA1M_A
;
11993 digest
[1] -= SHA1M_B
;
11994 digest
[2] -= SHA1M_C
;
11995 digest
[3] -= SHA1M_D
;
11996 digest
[4] -= SHA1M_E
;
11998 return (PARSER_OK
);
12001 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12003 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12005 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12007 u32
*digest
= (u32
*) hash_buf
->digest
;
12009 salt_t
*salt
= hash_buf
->salt
;
12011 char *salt_buf
= input_buf
+ 6;
12015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12017 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12021 salt
->salt_len
= salt_len
;
12023 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12025 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12026 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12027 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12028 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12029 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12031 digest
[0] -= SHA1M_A
;
12032 digest
[1] -= SHA1M_B
;
12033 digest
[2] -= SHA1M_C
;
12034 digest
[3] -= SHA1M_D
;
12035 digest
[4] -= SHA1M_E
;
12037 return (PARSER_OK
);
12040 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12042 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12044 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12046 u32
*digest
= (u32
*) hash_buf
->digest
;
12048 salt_t
*salt
= hash_buf
->salt
;
12050 char *salt_buf
= input_buf
+ 6;
12054 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12056 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12058 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12060 salt
->salt_len
= salt_len
;
12062 char *hash_pos
= input_buf
+ 6 + 8;
12064 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12065 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12066 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12067 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12068 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12070 digest
[0] -= SHA1M_A
;
12071 digest
[1] -= SHA1M_B
;
12072 digest
[2] -= SHA1M_C
;
12073 digest
[3] -= SHA1M_D
;
12074 digest
[4] -= SHA1M_E
;
12076 return (PARSER_OK
);
12079 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12081 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12083 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12085 u64
*digest
= (u64
*) hash_buf
->digest
;
12087 salt_t
*salt
= hash_buf
->salt
;
12089 char *salt_buf
= input_buf
+ 6;
12093 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12095 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12097 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12099 salt
->salt_len
= salt_len
;
12101 char *hash_pos
= input_buf
+ 6 + 8;
12103 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12104 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12105 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12106 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12107 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12108 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12109 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12110 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12112 digest
[0] -= SHA512M_A
;
12113 digest
[1] -= SHA512M_B
;
12114 digest
[2] -= SHA512M_C
;
12115 digest
[3] -= SHA512M_D
;
12116 digest
[4] -= SHA512M_E
;
12117 digest
[5] -= SHA512M_F
;
12118 digest
[6] -= SHA512M_G
;
12119 digest
[7] -= SHA512M_H
;
12121 return (PARSER_OK
);
12124 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12126 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12128 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12132 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12135 u32
*digest
= (u32
*) hash_buf
->digest
;
12137 salt_t
*salt
= hash_buf
->salt
;
12139 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12140 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12144 digest
[0] = byte_swap_32 (digest
[0]);
12145 digest
[1] = byte_swap_32 (digest
[1]);
12147 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12149 uint salt_len
= input_len
- 16 - 1;
12151 char *salt_buf
= input_buf
+ 16 + 1;
12153 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12155 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12157 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12159 salt
->salt_len
= salt_len
;
12161 return (PARSER_OK
);
12164 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12166 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12168 u32
*digest
= (u32
*) hash_buf
->digest
;
12170 salt_t
*salt
= hash_buf
->salt
;
12172 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12173 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12174 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12175 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12176 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12178 digest
[0] -= SHA1M_A
;
12179 digest
[1] -= SHA1M_B
;
12180 digest
[2] -= SHA1M_C
;
12181 digest
[3] -= SHA1M_D
;
12182 digest
[4] -= SHA1M_E
;
12184 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12186 uint salt_len
= input_len
- 40 - 1;
12188 char *salt_buf
= input_buf
+ 40 + 1;
12190 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12196 salt
->salt_len
= salt_len
;
12198 return (PARSER_OK
);
12201 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12203 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12205 u32
*digest
= (u32
*) hash_buf
->digest
;
12207 salt_t
*salt
= hash_buf
->salt
;
12209 char *hash_pos
= input_buf
;
12211 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12212 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12213 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12214 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12215 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12216 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12217 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12218 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12219 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12220 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12221 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12222 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12223 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12224 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12225 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12226 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12228 char *salt_pos
= input_buf
+ 128;
12230 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12231 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12232 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12233 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12235 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12236 salt
->salt_len
= 16;
12238 return (PARSER_OK
);
12241 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12243 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12245 u32
*digest
= (u32
*) hash_buf
->digest
;
12247 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12248 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12249 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12250 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12251 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12252 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12253 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12254 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12256 digest
[0] -= SHA256M_A
;
12257 digest
[1] -= SHA256M_B
;
12258 digest
[2] -= SHA256M_C
;
12259 digest
[3] -= SHA256M_D
;
12260 digest
[4] -= SHA256M_E
;
12261 digest
[5] -= SHA256M_F
;
12262 digest
[6] -= SHA256M_G
;
12263 digest
[7] -= SHA256M_H
;
12265 return (PARSER_OK
);
12268 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12270 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12272 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12276 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12279 u32
*digest
= (u32
*) hash_buf
->digest
;
12281 salt_t
*salt
= hash_buf
->salt
;
12283 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12284 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12285 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12286 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12287 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12288 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12289 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12290 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12292 digest
[0] -= SHA256M_A
;
12293 digest
[1] -= SHA256M_B
;
12294 digest
[2] -= SHA256M_C
;
12295 digest
[3] -= SHA256M_D
;
12296 digest
[4] -= SHA256M_E
;
12297 digest
[5] -= SHA256M_F
;
12298 digest
[6] -= SHA256M_G
;
12299 digest
[7] -= SHA256M_H
;
12301 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12303 uint salt_len
= input_len
- 64 - 1;
12305 char *salt_buf
= input_buf
+ 64 + 1;
12307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12313 salt
->salt_len
= salt_len
;
12315 return (PARSER_OK
);
12318 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12320 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12322 u64
*digest
= (u64
*) hash_buf
->digest
;
12324 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12325 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12326 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12327 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12328 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12329 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12333 digest
[0] -= SHA384M_A
;
12334 digest
[1] -= SHA384M_B
;
12335 digest
[2] -= SHA384M_C
;
12336 digest
[3] -= SHA384M_D
;
12337 digest
[4] -= SHA384M_E
;
12338 digest
[5] -= SHA384M_F
;
12342 return (PARSER_OK
);
12345 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12347 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12349 u64
*digest
= (u64
*) hash_buf
->digest
;
12351 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12352 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12353 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12354 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12355 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12356 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12357 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12358 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12360 digest
[0] -= SHA512M_A
;
12361 digest
[1] -= SHA512M_B
;
12362 digest
[2] -= SHA512M_C
;
12363 digest
[3] -= SHA512M_D
;
12364 digest
[4] -= SHA512M_E
;
12365 digest
[5] -= SHA512M_F
;
12366 digest
[6] -= SHA512M_G
;
12367 digest
[7] -= SHA512M_H
;
12369 return (PARSER_OK
);
12372 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12374 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12376 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12380 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12383 u64
*digest
= (u64
*) hash_buf
->digest
;
12385 salt_t
*salt
= hash_buf
->salt
;
12387 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12388 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12389 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12390 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12391 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12392 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12393 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12394 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12396 digest
[0] -= SHA512M_A
;
12397 digest
[1] -= SHA512M_B
;
12398 digest
[2] -= SHA512M_C
;
12399 digest
[3] -= SHA512M_D
;
12400 digest
[4] -= SHA512M_E
;
12401 digest
[5] -= SHA512M_F
;
12402 digest
[6] -= SHA512M_G
;
12403 digest
[7] -= SHA512M_H
;
12405 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12407 uint salt_len
= input_len
- 128 - 1;
12409 char *salt_buf
= input_buf
+ 128 + 1;
12411 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12413 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12415 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12417 salt
->salt_len
= salt_len
;
12419 return (PARSER_OK
);
12422 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12424 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12426 u64
*digest
= (u64
*) hash_buf
->digest
;
12428 salt_t
*salt
= hash_buf
->salt
;
12430 char *salt_pos
= input_buf
+ 3;
12432 uint iterations_len
= 0;
12434 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12438 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12440 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12441 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12445 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12449 iterations_len
+= 8;
12453 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12456 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12458 char *hash_pos
= strchr (salt_pos
, '$');
12460 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12462 uint salt_len
= hash_pos
- salt_pos
;
12464 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12466 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12468 salt
->salt_len
= salt_len
;
12472 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12474 return (PARSER_OK
);
12477 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12479 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12481 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12483 u64
*digest
= (u64
*) hash_buf
->digest
;
12485 salt_t
*salt
= hash_buf
->salt
;
12487 uint keccak_mdlen
= input_len
/ 2;
12489 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12491 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12493 digest
[i
] = byte_swap_64 (digest
[i
]);
12496 salt
->keccak_mdlen
= keccak_mdlen
;
12498 return (PARSER_OK
);
12501 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12503 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12505 u32
*digest
= (u32
*) hash_buf
->digest
;
12507 salt_t
*salt
= hash_buf
->salt
;
12509 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12512 * Parse that strange long line
12517 size_t in_len
[9] = { 0 };
12519 in_off
[0] = strtok (input_buf
, ":");
12521 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12523 in_len
[0] = strlen (in_off
[0]);
12527 for (i
= 1; i
< 9; i
++)
12529 in_off
[i
] = strtok (NULL
, ":");
12531 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 in_len
[i
] = strlen (in_off
[i
]);
12536 char *ptr
= (char *) ikepsk
->msg_buf
;
12538 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12539 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12540 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12541 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12542 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12543 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12547 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12549 ptr
= (char *) ikepsk
->nr_buf
;
12551 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12552 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12556 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12559 * Store to database
12564 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12565 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12566 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12567 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12569 digest
[0] = byte_swap_32 (digest
[0]);
12570 digest
[1] = byte_swap_32 (digest
[1]);
12571 digest
[2] = byte_swap_32 (digest
[2]);
12572 digest
[3] = byte_swap_32 (digest
[3]);
12574 salt
->salt_len
= 32;
12576 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12577 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12578 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12579 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12580 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12581 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12582 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12583 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12585 return (PARSER_OK
);
12588 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12590 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12592 u32
*digest
= (u32
*) hash_buf
->digest
;
12594 salt_t
*salt
= hash_buf
->salt
;
12596 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12599 * Parse that strange long line
12604 size_t in_len
[9] = { 0 };
12606 in_off
[0] = strtok (input_buf
, ":");
12608 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12610 in_len
[0] = strlen (in_off
[0]);
12614 for (i
= 1; i
< 9; i
++)
12616 in_off
[i
] = strtok (NULL
, ":");
12618 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12620 in_len
[i
] = strlen (in_off
[i
]);
12623 char *ptr
= (char *) ikepsk
->msg_buf
;
12625 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12626 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12627 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12628 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12629 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12630 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12634 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12636 ptr
= (char *) ikepsk
->nr_buf
;
12638 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12639 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12643 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12646 * Store to database
12651 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12652 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12653 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12654 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12655 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12657 salt
->salt_len
= 32;
12659 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12660 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12661 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12662 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12663 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12664 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12665 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12666 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12668 return (PARSER_OK
);
12671 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12673 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12675 u32
*digest
= (u32
*) hash_buf
->digest
;
12677 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12678 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12679 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12680 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12681 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12683 digest
[0] = byte_swap_32 (digest
[0]);
12684 digest
[1] = byte_swap_32 (digest
[1]);
12685 digest
[2] = byte_swap_32 (digest
[2]);
12686 digest
[3] = byte_swap_32 (digest
[3]);
12687 digest
[4] = byte_swap_32 (digest
[4]);
12689 return (PARSER_OK
);
12692 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12694 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12696 u32
*digest
= (u32
*) hash_buf
->digest
;
12698 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12699 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12700 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12701 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12702 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12703 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12704 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12705 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12706 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12707 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12708 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12709 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12710 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12711 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12712 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12713 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12715 return (PARSER_OK
);
12718 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12720 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12722 u32
*digest
= (u32
*) hash_buf
->digest
;
12724 salt_t
*salt
= hash_buf
->salt
;
12726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12730 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12732 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12734 uint salt_len
= input_len
- 40 - 1;
12736 char *salt_buf
= input_buf
+ 40 + 1;
12738 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12740 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12742 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12744 salt
->salt_len
= salt_len
;
12746 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12748 return (PARSER_OK
);
12751 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12753 u32
*digest
= (u32
*) hash_buf
->digest
;
12755 salt_t
*salt
= hash_buf
->salt
;
12757 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12759 if (input_len
== 0)
12761 log_error ("TrueCrypt container not specified");
12766 FILE *fp
= fopen (input_buf
, "rb");
12770 log_error ("%s: %s", input_buf
, strerror (errno
));
12775 char buf
[512] = { 0 };
12777 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12781 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12783 memcpy (tc
->salt_buf
, buf
, 64);
12785 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12787 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12789 salt
->salt_len
= 4;
12791 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12793 tc
->signature
= 0x45555254; // "TRUE"
12795 digest
[0] = tc
->data_buf
[0];
12797 return (PARSER_OK
);
12800 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12802 u32
*digest
= (u32
*) hash_buf
->digest
;
12804 salt_t
*salt
= hash_buf
->salt
;
12806 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12808 if (input_len
== 0)
12810 log_error ("TrueCrypt container not specified");
12815 FILE *fp
= fopen (input_buf
, "rb");
12819 log_error ("%s: %s", input_buf
, strerror (errno
));
12824 char buf
[512] = { 0 };
12826 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12830 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12832 memcpy (tc
->salt_buf
, buf
, 64);
12834 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12836 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12838 salt
->salt_len
= 4;
12840 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
12842 tc
->signature
= 0x45555254; // "TRUE"
12844 digest
[0] = tc
->data_buf
[0];
12846 return (PARSER_OK
);
12849 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12851 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12853 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12855 u32
*digest
= (u32
*) hash_buf
->digest
;
12857 salt_t
*salt
= hash_buf
->salt
;
12859 char *salt_pos
= input_buf
+ 6;
12861 char *hash_pos
= strchr (salt_pos
, '$');
12863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12865 uint salt_len
= hash_pos
- salt_pos
;
12867 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12869 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12871 salt
->salt_len
= salt_len
;
12873 salt
->salt_iter
= 1000;
12877 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12879 return (PARSER_OK
);
12882 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12884 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12886 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12888 u32
*digest
= (u32
*) hash_buf
->digest
;
12890 salt_t
*salt
= hash_buf
->salt
;
12892 char *iter_pos
= input_buf
+ 7;
12894 char *salt_pos
= strchr (iter_pos
, '$');
12896 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12900 char *hash_pos
= strchr (salt_pos
, '$');
12902 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12904 uint salt_len
= hash_pos
- salt_pos
;
12906 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12908 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12910 salt
->salt_len
= salt_len
;
12912 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12914 salt
->salt_sign
[0] = atoi (salt_iter
);
12916 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12920 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12922 digest
[0] = byte_swap_32 (digest
[0]);
12923 digest
[1] = byte_swap_32 (digest
[1]);
12924 digest
[2] = byte_swap_32 (digest
[2]);
12925 digest
[3] = byte_swap_32 (digest
[3]);
12926 digest
[4] = byte_swap_32 (digest
[4]);
12928 return (PARSER_OK
);
12931 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12933 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12935 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12937 u32
*digest
= (u32
*) hash_buf
->digest
;
12939 salt_t
*salt
= hash_buf
->salt
;
12941 char *iter_pos
= input_buf
+ 9;
12943 char *salt_pos
= strchr (iter_pos
, '$');
12945 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12949 char *hash_pos
= strchr (salt_pos
, '$');
12951 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12953 uint salt_len
= hash_pos
- salt_pos
;
12955 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12957 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12959 salt
->salt_len
= salt_len
;
12961 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12963 salt
->salt_sign
[0] = atoi (salt_iter
);
12965 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12969 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12971 digest
[0] = byte_swap_32 (digest
[0]);
12972 digest
[1] = byte_swap_32 (digest
[1]);
12973 digest
[2] = byte_swap_32 (digest
[2]);
12974 digest
[3] = byte_swap_32 (digest
[3]);
12975 digest
[4] = byte_swap_32 (digest
[4]);
12976 digest
[5] = byte_swap_32 (digest
[5]);
12977 digest
[6] = byte_swap_32 (digest
[6]);
12978 digest
[7] = byte_swap_32 (digest
[7]);
12980 return (PARSER_OK
);
12983 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12985 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12987 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12989 u64
*digest
= (u64
*) hash_buf
->digest
;
12991 salt_t
*salt
= hash_buf
->salt
;
12993 char *iter_pos
= input_buf
+ 9;
12995 char *salt_pos
= strchr (iter_pos
, '$');
12997 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13001 char *hash_pos
= strchr (salt_pos
, '$');
13003 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13005 uint salt_len
= hash_pos
- salt_pos
;
13007 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13009 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13011 salt
->salt_len
= salt_len
;
13013 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13015 salt
->salt_sign
[0] = atoi (salt_iter
);
13017 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13021 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13023 digest
[0] = byte_swap_64 (digest
[0]);
13024 digest
[1] = byte_swap_64 (digest
[1]);
13025 digest
[2] = byte_swap_64 (digest
[2]);
13026 digest
[3] = byte_swap_64 (digest
[3]);
13027 digest
[4] = byte_swap_64 (digest
[4]);
13028 digest
[5] = byte_swap_64 (digest
[5]);
13029 digest
[6] = byte_swap_64 (digest
[6]);
13030 digest
[7] = byte_swap_64 (digest
[7]);
13032 return (PARSER_OK
);
13035 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13037 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13039 u32
*digest
= (u32
*) hash_buf
->digest
;
13041 salt_t
*salt
= hash_buf
->salt
;
13043 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13049 char *iterations_pos
= input_buf
;
13051 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13053 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13055 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13057 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13061 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13063 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13065 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13067 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13069 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13071 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13076 * pbkdf2 iterations
13079 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13082 * handle salt encoding
13085 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13087 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13089 const char p0
= saltbuf_pos
[i
+ 0];
13090 const char p1
= saltbuf_pos
[i
+ 1];
13092 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13093 | hex_convert (p0
) << 4;
13096 salt
->salt_len
= saltbuf_len
/ 2;
13099 * handle cipher encoding
13102 uint
*tmp
= (uint
*) mymalloc (32);
13104 char *cipherbuf_ptr
= (char *) tmp
;
13106 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13108 const char p0
= cipherbuf_pos
[i
+ 0];
13109 const char p1
= cipherbuf_pos
[i
+ 1];
13111 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13112 | hex_convert (p0
) << 4;
13115 // iv is stored at salt_buf 4 (length 16)
13116 // data is stored at salt_buf 8 (length 16)
13118 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13119 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13120 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13121 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13123 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13124 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13125 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13126 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13130 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13132 const char p0
= cipherbuf_pos
[j
+ 0];
13133 const char p1
= cipherbuf_pos
[j
+ 1];
13135 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13136 | hex_convert (p0
) << 4;
13143 digest
[0] = 0x10101010;
13144 digest
[1] = 0x10101010;
13145 digest
[2] = 0x10101010;
13146 digest
[3] = 0x10101010;
13148 return (PARSER_OK
);
13151 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13153 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13155 u32
*digest
= (u32
*) hash_buf
->digest
;
13157 salt_t
*salt
= hash_buf
->salt
;
13159 char *hashbuf_pos
= input_buf
;
13161 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13163 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13165 uint hash_len
= iterations_pos
- hashbuf_pos
;
13167 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13171 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13173 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13175 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13179 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13181 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13183 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13185 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13187 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13189 salt
->salt_len
= salt_len
;
13191 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13193 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13194 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13195 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13196 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13198 return (PARSER_OK
);
13201 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13203 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13205 u32
*digest
= (u32
*) hash_buf
->digest
;
13207 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13208 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13209 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13210 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13211 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13212 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13213 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13214 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13216 digest
[0] = byte_swap_32 (digest
[0]);
13217 digest
[1] = byte_swap_32 (digest
[1]);
13218 digest
[2] = byte_swap_32 (digest
[2]);
13219 digest
[3] = byte_swap_32 (digest
[3]);
13220 digest
[4] = byte_swap_32 (digest
[4]);
13221 digest
[5] = byte_swap_32 (digest
[5]);
13222 digest
[6] = byte_swap_32 (digest
[6]);
13223 digest
[7] = byte_swap_32 (digest
[7]);
13225 return (PARSER_OK
);
13228 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13230 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13232 u32
*digest
= (u32
*) hash_buf
->digest
;
13234 salt_t
*salt
= hash_buf
->salt
;
13236 char *salt_pos
= input_buf
+ 3;
13238 uint iterations_len
= 0;
13240 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13244 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13246 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13247 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13251 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13255 iterations_len
+= 8;
13259 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13262 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13264 char *hash_pos
= strchr (salt_pos
, '$');
13266 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13268 uint salt_len
= hash_pos
- salt_pos
;
13270 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13272 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13274 salt
->salt_len
= salt_len
;
13278 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13280 return (PARSER_OK
);
13283 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13285 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13287 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13289 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13291 u64
*digest
= (u64
*) hash_buf
->digest
;
13293 salt_t
*salt
= hash_buf
->salt
;
13295 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13297 char *iter_pos
= input_buf
+ 4;
13299 char *salt_pos
= strchr (iter_pos
, '$');
13301 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13305 char *hash_pos
= strchr (salt_pos
, '$');
13307 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13309 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13313 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13314 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13315 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13316 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13317 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13318 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13319 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13320 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13322 uint salt_len
= hash_pos
- salt_pos
- 1;
13324 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13326 salt
->salt_len
= salt_len
/ 2;
13328 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13329 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13330 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13331 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13332 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13333 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13334 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13335 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13337 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13338 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13339 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13340 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13341 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13342 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13343 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13344 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13345 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13346 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13348 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13350 salt
->salt_iter
= atoi (iter_pos
) - 1;
13352 return (PARSER_OK
);
13355 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13357 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13359 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13361 u32
*digest
= (u32
*) hash_buf
->digest
;
13363 salt_t
*salt
= hash_buf
->salt
;
13365 char *salt_pos
= input_buf
+ 14;
13367 char *hash_pos
= strchr (salt_pos
, '*');
13369 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13373 uint salt_len
= hash_pos
- salt_pos
- 1;
13375 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13377 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13379 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13381 salt
->salt_len
= salt_len
;
13383 u8 tmp_buf
[100] = { 0 };
13385 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13387 memcpy (digest
, tmp_buf
, 32);
13389 digest
[0] = byte_swap_32 (digest
[0]);
13390 digest
[1] = byte_swap_32 (digest
[1]);
13391 digest
[2] = byte_swap_32 (digest
[2]);
13392 digest
[3] = byte_swap_32 (digest
[3]);
13393 digest
[4] = byte_swap_32 (digest
[4]);
13394 digest
[5] = byte_swap_32 (digest
[5]);
13395 digest
[6] = byte_swap_32 (digest
[6]);
13396 digest
[7] = byte_swap_32 (digest
[7]);
13398 digest
[0] -= SHA256M_A
;
13399 digest
[1] -= SHA256M_B
;
13400 digest
[2] -= SHA256M_C
;
13401 digest
[3] -= SHA256M_D
;
13402 digest
[4] -= SHA256M_E
;
13403 digest
[5] -= SHA256M_F
;
13404 digest
[6] -= SHA256M_G
;
13405 digest
[7] -= SHA256M_H
;
13407 return (PARSER_OK
);
13410 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13412 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13414 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13416 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13418 u64
*digest
= (u64
*) hash_buf
->digest
;
13420 salt_t
*salt
= hash_buf
->salt
;
13422 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13424 char *iter_pos
= input_buf
+ 19;
13426 char *salt_pos
= strchr (iter_pos
, '.');
13428 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13432 char *hash_pos
= strchr (salt_pos
, '.');
13434 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13436 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13440 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13441 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13442 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13443 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13444 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13445 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13446 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13447 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13449 uint salt_len
= hash_pos
- salt_pos
- 1;
13453 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13457 for (i
= 0; i
< salt_len
; i
++)
13459 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13462 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13463 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13465 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13467 salt
->salt_len
= salt_len
;
13469 salt
->salt_iter
= atoi (iter_pos
) - 1;
13471 return (PARSER_OK
);
13474 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13476 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13478 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13480 u64
*digest
= (u64
*) hash_buf
->digest
;
13482 salt_t
*salt
= hash_buf
->salt
;
13484 u8 tmp_buf
[120] = { 0 };
13486 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13488 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13490 memcpy (digest
, tmp_buf
, 64);
13492 digest
[0] = byte_swap_64 (digest
[0]);
13493 digest
[1] = byte_swap_64 (digest
[1]);
13494 digest
[2] = byte_swap_64 (digest
[2]);
13495 digest
[3] = byte_swap_64 (digest
[3]);
13496 digest
[4] = byte_swap_64 (digest
[4]);
13497 digest
[5] = byte_swap_64 (digest
[5]);
13498 digest
[6] = byte_swap_64 (digest
[6]);
13499 digest
[7] = byte_swap_64 (digest
[7]);
13501 digest
[0] -= SHA512M_A
;
13502 digest
[1] -= SHA512M_B
;
13503 digest
[2] -= SHA512M_C
;
13504 digest
[3] -= SHA512M_D
;
13505 digest
[4] -= SHA512M_E
;
13506 digest
[5] -= SHA512M_F
;
13507 digest
[6] -= SHA512M_G
;
13508 digest
[7] -= SHA512M_H
;
13510 int salt_len
= tmp_len
- 64;
13512 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13514 salt
->salt_len
= salt_len
;
13516 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13518 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13520 char *ptr
= (char *) salt
->salt_buf
;
13522 ptr
[salt
->salt_len
] = 0x80;
13525 return (PARSER_OK
);
13528 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13530 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13532 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13536 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13539 u32
*digest
= (u32
*) hash_buf
->digest
;
13541 salt_t
*salt
= hash_buf
->salt
;
13543 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13544 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13545 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13546 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13548 digest
[0] = byte_swap_32 (digest
[0]);
13549 digest
[1] = byte_swap_32 (digest
[1]);
13550 digest
[2] = byte_swap_32 (digest
[2]);
13551 digest
[3] = byte_swap_32 (digest
[3]);
13553 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13555 uint salt_len
= input_len
- 32 - 1;
13557 char *salt_buf
= input_buf
+ 32 + 1;
13559 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13561 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13563 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13565 salt
->salt_len
= salt_len
;
13567 return (PARSER_OK
);
13570 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13572 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13574 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13578 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13581 u32
*digest
= (u32
*) hash_buf
->digest
;
13583 salt_t
*salt
= hash_buf
->salt
;
13585 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13586 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13587 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13588 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13589 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13591 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13593 uint salt_len
= input_len
- 40 - 1;
13595 char *salt_buf
= input_buf
+ 40 + 1;
13597 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13599 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13601 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13603 salt
->salt_len
= salt_len
;
13605 return (PARSER_OK
);
13608 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13610 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13612 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13616 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13619 u32
*digest
= (u32
*) hash_buf
->digest
;
13621 salt_t
*salt
= hash_buf
->salt
;
13623 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13624 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13625 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13626 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13627 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13628 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13629 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13630 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13632 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13634 uint salt_len
= input_len
- 64 - 1;
13636 char *salt_buf
= input_buf
+ 64 + 1;
13638 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13640 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13642 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13644 salt
->salt_len
= salt_len
;
13646 return (PARSER_OK
);
13649 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13651 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13653 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13657 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13660 u64
*digest
= (u64
*) hash_buf
->digest
;
13662 salt_t
*salt
= hash_buf
->salt
;
13664 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13665 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13666 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13667 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13668 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13669 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13670 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13671 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13673 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13675 uint salt_len
= input_len
- 128 - 1;
13677 char *salt_buf
= input_buf
+ 128 + 1;
13679 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13681 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13683 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13685 salt
->salt_len
= salt_len
;
13687 return (PARSER_OK
);
13690 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13692 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13694 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13696 u32
*digest
= (u32
*) hash_buf
->digest
;
13698 salt_t
*salt
= hash_buf
->salt
;
13700 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13706 char *user_pos
= input_buf
+ 10 + 1;
13708 char *realm_pos
= strchr (user_pos
, '$');
13710 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13712 uint user_len
= realm_pos
- user_pos
;
13714 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13718 char *salt_pos
= strchr (realm_pos
, '$');
13720 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13722 uint realm_len
= salt_pos
- realm_pos
;
13724 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13728 char *data_pos
= strchr (salt_pos
, '$');
13730 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13732 uint salt_len
= data_pos
- salt_pos
;
13734 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13738 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13740 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13746 memcpy (krb5pa
->user
, user_pos
, user_len
);
13747 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13748 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13750 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13752 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13754 const char p0
= data_pos
[i
+ 0];
13755 const char p1
= data_pos
[i
+ 1];
13757 *timestamp_ptr
++ = hex_convert (p1
) << 0
13758 | hex_convert (p0
) << 4;
13761 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13763 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13765 const char p0
= data_pos
[i
+ 0];
13766 const char p1
= data_pos
[i
+ 1];
13768 *checksum_ptr
++ = hex_convert (p1
) << 0
13769 | hex_convert (p0
) << 4;
13773 * copy some data to generic buffers to make sorting happy
13776 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13777 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13778 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13779 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13780 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13781 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13782 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13783 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13784 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13786 salt
->salt_len
= 36;
13788 digest
[0] = krb5pa
->checksum
[0];
13789 digest
[1] = krb5pa
->checksum
[1];
13790 digest
[2] = krb5pa
->checksum
[2];
13791 digest
[3] = krb5pa
->checksum
[3];
13793 return (PARSER_OK
);
13796 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13798 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13800 u32
*digest
= (u32
*) hash_buf
->digest
;
13802 salt_t
*salt
= hash_buf
->salt
;
13808 char *salt_pos
= input_buf
;
13810 char *hash_pos
= strchr (salt_pos
, '$');
13812 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13814 uint salt_len
= hash_pos
- salt_pos
;
13816 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13820 uint hash_len
= input_len
- 1 - salt_len
;
13822 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13830 for (uint i
= 0; i
< salt_len
; i
++)
13832 if (salt_pos
[i
] == ' ') continue;
13837 // SAP user names cannot be longer than 12 characters
13838 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13840 // SAP user name cannot start with ! or ?
13841 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13849 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13851 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13853 salt
->salt_len
= salt_len
;
13855 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13856 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13860 digest
[0] = byte_swap_32 (digest
[0]);
13861 digest
[1] = byte_swap_32 (digest
[1]);
13863 return (PARSER_OK
);
13866 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13868 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13870 u32
*digest
= (u32
*) hash_buf
->digest
;
13872 salt_t
*salt
= hash_buf
->salt
;
13878 char *salt_pos
= input_buf
;
13880 char *hash_pos
= strchr (salt_pos
, '$');
13882 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13884 uint salt_len
= hash_pos
- salt_pos
;
13886 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13890 uint hash_len
= input_len
- 1 - salt_len
;
13892 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13900 for (uint i
= 0; i
< salt_len
; i
++)
13902 if (salt_pos
[i
] == ' ') continue;
13907 // SAP user names cannot be longer than 12 characters
13908 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13909 // so far nobody complained so we stay with this because it helps in optimization
13910 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13912 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13914 // SAP user name cannot start with ! or ?
13915 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13921 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13923 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13925 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13927 salt
->salt_len
= salt_len
;
13929 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13930 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13931 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13932 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13933 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13935 return (PARSER_OK
);
13938 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13940 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13942 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13944 u64
*digest
= (u64
*) hash_buf
->digest
;
13946 salt_t
*salt
= hash_buf
->salt
;
13948 char *iter_pos
= input_buf
+ 3;
13950 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13952 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13954 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13956 salt
->salt_iter
= salt_iter
;
13958 char *salt_pos
= iter_pos
+ 1;
13962 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13964 salt
->salt_len
= salt_len
;
13966 char *hash_pos
= salt_pos
+ salt_len
;
13968 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13972 char *tmp
= (char *) salt
->salt_buf_pc
;
13974 tmp
[0] = hash_pos
[42];
13978 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13979 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13980 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13981 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13987 return (PARSER_OK
);
13990 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13992 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13994 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13996 u32
*digest
= (u32
*) hash_buf
->digest
;
13998 salt_t
*salt
= hash_buf
->salt
;
14000 char *salt_buf
= input_buf
+ 6;
14002 uint salt_len
= 16;
14004 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14006 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14008 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14010 salt
->salt_len
= salt_len
;
14012 char *hash_pos
= input_buf
+ 6 + 16;
14014 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14015 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14016 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14017 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14018 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14019 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14020 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14021 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14023 return (PARSER_OK
);
14026 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14028 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14030 u32
*digest
= (u32
*) hash_buf
->digest
;
14032 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14033 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14037 return (PARSER_OK
);
14040 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14042 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14044 u32
*digest
= (u32
*) hash_buf
->digest
;
14046 salt_t
*salt
= hash_buf
->salt
;
14048 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14050 char *saltbuf_pos
= input_buf
;
14052 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14054 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14056 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14058 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14059 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14061 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14065 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14067 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14069 char *salt_ptr
= (char *) saltbuf_pos
;
14070 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14075 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14077 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14080 rakp_ptr
[j
] = 0x80;
14082 rakp
->salt_len
= j
;
14084 for (i
= 0; i
< 64; i
++)
14086 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14089 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14090 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14091 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14092 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14093 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14094 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14095 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14096 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14098 salt
->salt_len
= 32; // muss min. 32 haben
14100 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14101 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14102 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14103 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14104 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14106 return (PARSER_OK
);
14109 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14111 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14113 u32
*digest
= (u32
*) hash_buf
->digest
;
14115 salt_t
*salt
= hash_buf
->salt
;
14117 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14119 char *salt_pos
= input_buf
+ 1;
14121 memcpy (salt
->salt_buf
, salt_pos
, 8);
14123 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14124 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14126 salt
->salt_len
= 8;
14128 char *hash_pos
= salt_pos
+ 8;
14130 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14131 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14132 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14133 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14134 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14136 digest
[0] -= SHA1M_A
;
14137 digest
[1] -= SHA1M_B
;
14138 digest
[2] -= SHA1M_C
;
14139 digest
[3] -= SHA1M_D
;
14140 digest
[4] -= SHA1M_E
;
14142 return (PARSER_OK
);
14145 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14147 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14149 u32
*digest
= (u32
*) hash_buf
->digest
;
14151 salt_t
*salt
= hash_buf
->salt
;
14153 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14154 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14155 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14156 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14158 digest
[0] = byte_swap_32 (digest
[0]);
14159 digest
[1] = byte_swap_32 (digest
[1]);
14160 digest
[2] = byte_swap_32 (digest
[2]);
14161 digest
[3] = byte_swap_32 (digest
[3]);
14163 digest
[0] -= MD5M_A
;
14164 digest
[1] -= MD5M_B
;
14165 digest
[2] -= MD5M_C
;
14166 digest
[3] -= MD5M_D
;
14168 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14170 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14172 u32
*salt_buf
= salt
->salt_buf
;
14174 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14175 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14176 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14177 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14179 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14180 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14181 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14182 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14184 salt
->salt_len
= 16 + 1;
14186 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14188 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14190 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14192 return (PARSER_OK
);
14195 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14197 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14199 u32
*digest
= (u32
*) hash_buf
->digest
;
14201 salt_t
*salt
= hash_buf
->salt
;
14203 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14209 char *hashbuf_pos
= input_buf
;
14211 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14213 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14215 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14217 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14221 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14223 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14225 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14227 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14231 char *databuf_pos
= strchr (iteration_pos
, ':');
14233 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14235 const uint iteration_len
= databuf_pos
- iteration_pos
;
14237 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14238 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14240 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14242 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14243 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14249 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14250 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14251 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14252 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14253 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14254 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14255 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14256 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14260 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14262 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14264 const char p0
= saltbuf_pos
[i
+ 0];
14265 const char p1
= saltbuf_pos
[i
+ 1];
14267 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14268 | hex_convert (p0
) << 4;
14271 salt
->salt_buf
[4] = 0x01000000;
14272 salt
->salt_buf
[5] = 0x80;
14274 salt
->salt_len
= saltbuf_len
/ 2;
14278 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14282 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14284 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14286 const char p0
= databuf_pos
[i
+ 0];
14287 const char p1
= databuf_pos
[i
+ 1];
14289 *databuf_ptr
++ = hex_convert (p1
) << 0
14290 | hex_convert (p0
) << 4;
14293 *databuf_ptr
++ = 0x80;
14295 for (uint i
= 0; i
< 512; i
++)
14297 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14300 cloudkey
->data_len
= databuf_len
/ 2;
14302 return (PARSER_OK
);
14305 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14307 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14309 u32
*digest
= (u32
*) hash_buf
->digest
;
14311 salt_t
*salt
= hash_buf
->salt
;
14317 char *hashbuf_pos
= input_buf
;
14319 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14321 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14323 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14325 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14329 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14331 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14333 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14335 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14337 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14341 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14343 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14345 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14347 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14349 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14353 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14355 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14356 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14358 // ok, the plan for this algorithm is the following:
14359 // we have 2 salts here, the domain-name and a random salt
14360 // while both are used in the initial transformation,
14361 // only the random salt is used in the following iterations
14362 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14363 // and one that includes only the real salt (stored into salt_buf[]).
14364 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14366 u8 tmp_buf
[100] = { 0 };
14368 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14370 memcpy (digest
, tmp_buf
, 20);
14372 digest
[0] = byte_swap_32 (digest
[0]);
14373 digest
[1] = byte_swap_32 (digest
[1]);
14374 digest
[2] = byte_swap_32 (digest
[2]);
14375 digest
[3] = byte_swap_32 (digest
[3]);
14376 digest
[4] = byte_swap_32 (digest
[4]);
14380 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14382 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14384 char *len_ptr
= NULL
;
14386 for (uint i
= 0; i
< domainbuf_len
; i
++)
14388 if (salt_buf_pc_ptr
[i
] == '.')
14390 len_ptr
= &salt_buf_pc_ptr
[i
];
14400 salt
->salt_buf_pc
[7] = domainbuf_len
;
14404 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14406 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14408 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14410 salt
->salt_len
= salt_len
;
14414 salt
->salt_iter
= atoi (iteration_pos
);
14416 return (PARSER_OK
);
14419 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14421 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14423 u32
*digest
= (u32
*) hash_buf
->digest
;
14425 salt_t
*salt
= hash_buf
->salt
;
14427 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14428 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14429 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14430 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14431 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14433 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14435 uint salt_len
= input_len
- 40 - 1;
14437 char *salt_buf
= input_buf
+ 40 + 1;
14439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14441 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14445 salt
->salt_len
= salt_len
;
14447 return (PARSER_OK
);
14450 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14452 const u8 ascii_to_ebcdic
[] =
14454 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14455 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14456 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14457 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14458 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14459 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14460 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14461 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14462 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14463 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14464 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14465 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14466 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14467 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14468 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14469 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14472 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14474 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14476 u32
*digest
= (u32
*) hash_buf
->digest
;
14478 salt_t
*salt
= hash_buf
->salt
;
14480 char *salt_pos
= input_buf
+ 6 + 1;
14482 char *digest_pos
= strchr (salt_pos
, '*');
14484 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14486 uint salt_len
= digest_pos
- salt_pos
;
14488 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14490 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14492 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14496 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14497 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14499 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14501 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14503 salt
->salt_len
= salt_len
;
14505 for (uint i
= 0; i
< salt_len
; i
++)
14507 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14509 for (uint i
= salt_len
; i
< 8; i
++)
14511 salt_buf_pc_ptr
[i
] = 0x40;
14516 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14518 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14519 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14521 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14522 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14524 digest
[0] = byte_swap_32 (digest
[0]);
14525 digest
[1] = byte_swap_32 (digest
[1]);
14527 IP (digest
[0], digest
[1], tt
);
14529 digest
[0] = rotr32 (digest
[0], 29);
14530 digest
[1] = rotr32 (digest
[1], 29);
14534 return (PARSER_OK
);
14537 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14539 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14541 u32
*digest
= (u32
*) hash_buf
->digest
;
14543 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14544 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14545 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14546 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14548 digest
[0] = byte_swap_32 (digest
[0]);
14549 digest
[1] = byte_swap_32 (digest
[1]);
14550 digest
[2] = byte_swap_32 (digest
[2]);
14551 digest
[3] = byte_swap_32 (digest
[3]);
14553 return (PARSER_OK
);
14556 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14558 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14560 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14562 u32
*digest
= (u32
*) hash_buf
->digest
;
14564 salt_t
*salt
= hash_buf
->salt
;
14566 u8 tmp_buf
[120] = { 0 };
14568 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14570 tmp_buf
[3] += -4; // dont ask!
14572 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14574 salt
->salt_len
= 5;
14576 memcpy (digest
, tmp_buf
+ 5, 9);
14578 // yes, only 9 byte are needed to crack, but 10 to display
14580 salt
->salt_buf_pc
[7] = input_buf
[20];
14582 return (PARSER_OK
);
14585 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14587 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14589 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14591 u32
*digest
= (u32
*) hash_buf
->digest
;
14593 salt_t
*salt
= hash_buf
->salt
;
14595 u8 tmp_buf
[120] = { 0 };
14597 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14599 tmp_buf
[3] += -4; // dont ask!
14603 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14605 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)
14609 char tmp_iter_buf
[11] = { 0 };
14611 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14613 tmp_iter_buf
[10] = 0;
14615 salt
->salt_iter
= atoi (tmp_iter_buf
);
14617 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14619 return (PARSER_SALT_ITERATION
);
14622 salt
->salt_iter
--; // first round in init
14624 // 2 additional bytes for display only
14626 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14627 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14631 memcpy (digest
, tmp_buf
+ 28, 8);
14633 digest
[0] = byte_swap_32 (digest
[0]);
14634 digest
[1] = byte_swap_32 (digest
[1]);
14638 return (PARSER_OK
);
14641 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14643 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14645 u32
*digest
= (u32
*) hash_buf
->digest
;
14647 salt_t
*salt
= hash_buf
->salt
;
14649 char *salt_buf_pos
= input_buf
;
14651 char *hash_buf_pos
= salt_buf_pos
+ 6;
14653 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14654 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14655 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14656 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14657 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14658 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14659 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14660 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14662 digest
[0] -= SHA256M_A
;
14663 digest
[1] -= SHA256M_B
;
14664 digest
[2] -= SHA256M_C
;
14665 digest
[3] -= SHA256M_D
;
14666 digest
[4] -= SHA256M_E
;
14667 digest
[5] -= SHA256M_F
;
14668 digest
[6] -= SHA256M_G
;
14669 digest
[7] -= SHA256M_H
;
14671 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14673 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14675 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14677 salt
->salt_len
= salt_len
;
14679 return (PARSER_OK
);
14682 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14684 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14686 u32
*digest
= (u32
*) hash_buf
->digest
;
14688 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14690 salt_t
*salt
= hash_buf
->salt
;
14692 char *salt_buf
= input_buf
+ 6;
14694 char *digest_buf
= strchr (salt_buf
, '$');
14696 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14698 uint salt_len
= digest_buf
- salt_buf
;
14700 digest_buf
++; // skip the '$' symbol
14702 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14704 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14706 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14708 salt
->salt_len
= salt_len
;
14710 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14711 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14712 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14713 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14715 digest
[0] = byte_swap_32 (digest
[0]);
14716 digest
[1] = byte_swap_32 (digest
[1]);
14717 digest
[2] = byte_swap_32 (digest
[2]);
14718 digest
[3] = byte_swap_32 (digest
[3]);
14720 digest
[0] -= MD5M_A
;
14721 digest
[1] -= MD5M_B
;
14722 digest
[2] -= MD5M_C
;
14723 digest
[3] -= MD5M_D
;
14725 return (PARSER_OK
);
14728 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14730 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14732 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14734 u32
*digest
= (u32
*) hash_buf
->digest
;
14736 salt_t
*salt
= hash_buf
->salt
;
14738 char *salt_buf
= input_buf
+ 3;
14740 char *digest_buf
= strchr (salt_buf
, '$');
14742 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14744 uint salt_len
= digest_buf
- salt_buf
;
14746 digest_buf
++; // skip the '$' symbol
14748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14750 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14754 salt_buf_ptr
[salt_len
] = 0x2d;
14756 salt
->salt_len
= salt_len
+ 1;
14758 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14759 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14760 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14761 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14763 digest
[0] = byte_swap_32 (digest
[0]);
14764 digest
[1] = byte_swap_32 (digest
[1]);
14765 digest
[2] = byte_swap_32 (digest
[2]);
14766 digest
[3] = byte_swap_32 (digest
[3]);
14768 digest
[0] -= MD5M_A
;
14769 digest
[1] -= MD5M_B
;
14770 digest
[2] -= MD5M_C
;
14771 digest
[3] -= MD5M_D
;
14773 return (PARSER_OK
);
14776 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14778 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14780 u32
*digest
= (u32
*) hash_buf
->digest
;
14782 salt_t
*salt
= hash_buf
->salt
;
14784 u8 tmp_buf
[100] = { 0 };
14786 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14788 memcpy (digest
, tmp_buf
, 20);
14790 digest
[0] = byte_swap_32 (digest
[0]);
14791 digest
[1] = byte_swap_32 (digest
[1]);
14792 digest
[2] = byte_swap_32 (digest
[2]);
14793 digest
[3] = byte_swap_32 (digest
[3]);
14794 digest
[4] = byte_swap_32 (digest
[4]);
14796 digest
[0] -= SHA1M_A
;
14797 digest
[1] -= SHA1M_B
;
14798 digest
[2] -= SHA1M_C
;
14799 digest
[3] -= SHA1M_D
;
14800 digest
[4] -= SHA1M_E
;
14802 salt
->salt_buf
[0] = 0x80;
14804 salt
->salt_len
= 0;
14806 return (PARSER_OK
);
14809 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14811 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14813 u32
*digest
= (u32
*) hash_buf
->digest
;
14815 salt_t
*salt
= hash_buf
->salt
;
14817 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14818 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14819 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14820 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14822 digest
[0] = byte_swap_32 (digest
[0]);
14823 digest
[1] = byte_swap_32 (digest
[1]);
14824 digest
[2] = byte_swap_32 (digest
[2]);
14825 digest
[3] = byte_swap_32 (digest
[3]);
14827 digest
[0] -= MD5M_A
;
14828 digest
[1] -= MD5M_B
;
14829 digest
[2] -= MD5M_C
;
14830 digest
[3] -= MD5M_D
;
14832 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14834 uint salt_len
= input_len
- 32 - 1;
14836 char *salt_buf
= input_buf
+ 32 + 1;
14838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14840 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14842 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14845 * add static "salt" part
14848 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14852 salt
->salt_len
= salt_len
;
14854 return (PARSER_OK
);
14857 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14859 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14861 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14863 u32
*digest
= (u32
*) hash_buf
->digest
;
14865 salt_t
*salt
= hash_buf
->salt
;
14867 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14873 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14875 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14877 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14879 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14881 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14885 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14887 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14889 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14891 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14895 char *keybuf_pos
= strchr (keylen_pos
, '$');
14897 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14899 uint keylen_len
= keybuf_pos
- keylen_pos
;
14901 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14905 char *databuf_pos
= strchr (keybuf_pos
, '$');
14907 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14909 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14911 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14915 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14917 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14923 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14924 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14925 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14926 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14928 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14929 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14930 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14931 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14933 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14934 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14935 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14936 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14938 salt
->salt_len
= 16;
14939 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14941 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14943 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14946 return (PARSER_OK
);
14949 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14951 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14953 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14955 u32
*digest
= (u32
*) hash_buf
->digest
;
14957 salt_t
*salt
= hash_buf
->salt
;
14963 // first is the N salt parameter
14965 char *N_pos
= input_buf
+ 6;
14967 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14971 salt
->scrypt_N
= atoi (N_pos
);
14975 char *r_pos
= strchr (N_pos
, ':');
14977 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14981 salt
->scrypt_r
= atoi (r_pos
);
14985 char *p_pos
= strchr (r_pos
, ':');
14987 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14991 salt
->scrypt_p
= atoi (p_pos
);
14995 char *saltbuf_pos
= strchr (p_pos
, ':');
14997 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15001 char *hash_pos
= strchr (saltbuf_pos
, ':');
15003 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15009 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15011 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15013 u8 tmp_buf
[33] = { 0 };
15015 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15017 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15019 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15021 salt
->salt_len
= tmp_len
;
15022 salt
->salt_iter
= 1;
15024 // digest - base64 decode
15026 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15028 tmp_len
= input_len
- (hash_pos
- input_buf
);
15030 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15032 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15034 memcpy (digest
, tmp_buf
, 32);
15036 return (PARSER_OK
);
15039 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15041 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15043 u32
*digest
= (u32
*) hash_buf
->digest
;
15045 salt_t
*salt
= hash_buf
->salt
;
15051 char decrypted
[76] = { 0 }; // iv + hash
15053 juniper_decrypt_hash (input_buf
, decrypted
);
15055 char *md5crypt_hash
= decrypted
+ 12;
15057 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15059 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15061 char *salt_pos
= md5crypt_hash
+ 3;
15063 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15065 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15067 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15071 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15073 return (PARSER_OK
);
15076 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15078 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15080 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15082 u32
*digest
= (u32
*) hash_buf
->digest
;
15084 salt_t
*salt
= hash_buf
->salt
;
15086 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15092 // first is *raw* salt
15094 char *salt_pos
= input_buf
+ 3;
15096 char *hash_pos
= strchr (salt_pos
, '$');
15098 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15100 uint salt_len
= hash_pos
- salt_pos
;
15102 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15106 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15108 memcpy (salt_buf_ptr
, salt_pos
, 14);
15110 salt_buf_ptr
[17] = 0x01;
15111 salt_buf_ptr
[18] = 0x80;
15113 // add some stuff to normal salt to make sorted happy
15115 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15116 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15117 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15118 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15120 salt
->salt_len
= salt_len
;
15121 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15123 // base64 decode hash
15125 u8 tmp_buf
[100] = { 0 };
15127 uint hash_len
= input_len
- 3 - salt_len
- 1;
15129 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15131 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15133 memcpy (digest
, tmp_buf
, 32);
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]);
15139 digest
[4] = byte_swap_32 (digest
[4]);
15140 digest
[5] = byte_swap_32 (digest
[5]);
15141 digest
[6] = byte_swap_32 (digest
[6]);
15142 digest
[7] = byte_swap_32 (digest
[7]);
15144 return (PARSER_OK
);
15147 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15149 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15151 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15153 u32
*digest
= (u32
*) hash_buf
->digest
;
15155 salt_t
*salt
= hash_buf
->salt
;
15161 // first is *raw* salt
15163 char *salt_pos
= input_buf
+ 3;
15165 char *hash_pos
= strchr (salt_pos
, '$');
15167 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15169 uint salt_len
= hash_pos
- salt_pos
;
15171 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15173 salt
->salt_len
= salt_len
;
15176 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15178 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15179 salt_buf_ptr
[salt_len
] = 0;
15181 // base64 decode hash
15183 u8 tmp_buf
[100] = { 0 };
15185 uint hash_len
= input_len
- 3 - salt_len
- 1;
15187 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15189 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15191 memcpy (digest
, tmp_buf
, 32);
15194 salt
->scrypt_N
= 16384;
15195 salt
->scrypt_r
= 1;
15196 salt
->scrypt_p
= 1;
15197 salt
->salt_iter
= 1;
15199 return (PARSER_OK
);
15202 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15204 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15206 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15208 u32
*digest
= (u32
*) hash_buf
->digest
;
15210 salt_t
*salt
= hash_buf
->salt
;
15212 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15218 char *version_pos
= input_buf
+ 8 + 1;
15220 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15222 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15224 u32 version_len
= verifierHashSize_pos
- version_pos
;
15226 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15228 verifierHashSize_pos
++;
15230 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15232 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15234 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15236 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15240 char *saltSize_pos
= strchr (keySize_pos
, '*');
15242 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15244 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15246 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15250 char *osalt_pos
= strchr (saltSize_pos
, '*');
15252 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15254 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15256 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15260 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15262 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15264 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15266 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15268 encryptedVerifier_pos
++;
15270 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15272 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15274 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15276 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15278 encryptedVerifierHash_pos
++;
15280 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;
15282 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15284 const uint version
= atoi (version_pos
);
15286 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15288 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15290 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15292 const uint keySize
= atoi (keySize_pos
);
15294 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15296 office2007
->keySize
= keySize
;
15298 const uint saltSize
= atoi (saltSize_pos
);
15300 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15306 salt
->salt_len
= 16;
15307 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15309 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15310 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15311 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15312 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15318 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15319 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15320 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15321 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15323 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15324 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15325 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15326 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15327 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15333 digest
[0] = office2007
->encryptedVerifierHash
[0];
15334 digest
[1] = office2007
->encryptedVerifierHash
[1];
15335 digest
[2] = office2007
->encryptedVerifierHash
[2];
15336 digest
[3] = office2007
->encryptedVerifierHash
[3];
15338 return (PARSER_OK
);
15341 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15343 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15345 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15347 u32
*digest
= (u32
*) hash_buf
->digest
;
15349 salt_t
*salt
= hash_buf
->salt
;
15351 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15357 char *version_pos
= input_buf
+ 8 + 1;
15359 char *spinCount_pos
= strchr (version_pos
, '*');
15361 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15363 u32 version_len
= spinCount_pos
- version_pos
;
15365 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15369 char *keySize_pos
= strchr (spinCount_pos
, '*');
15371 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15373 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15375 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15379 char *saltSize_pos
= strchr (keySize_pos
, '*');
15381 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15383 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15385 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15389 char *osalt_pos
= strchr (saltSize_pos
, '*');
15391 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15393 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15395 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15399 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15401 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15403 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15405 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15407 encryptedVerifier_pos
++;
15409 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15411 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15413 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15415 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15417 encryptedVerifierHash_pos
++;
15419 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;
15421 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15423 const uint version
= atoi (version_pos
);
15425 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15427 const uint spinCount
= atoi (spinCount_pos
);
15429 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15431 const uint keySize
= atoi (keySize_pos
);
15433 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15435 const uint saltSize
= atoi (saltSize_pos
);
15437 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15443 salt
->salt_len
= 16;
15444 salt
->salt_iter
= spinCount
;
15446 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15447 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15448 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15449 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15455 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15456 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15457 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15458 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15460 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15461 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15462 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15463 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15464 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15465 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15466 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15467 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15473 digest
[0] = office2010
->encryptedVerifierHash
[0];
15474 digest
[1] = office2010
->encryptedVerifierHash
[1];
15475 digest
[2] = office2010
->encryptedVerifierHash
[2];
15476 digest
[3] = office2010
->encryptedVerifierHash
[3];
15478 return (PARSER_OK
);
15481 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15483 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15485 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15487 u32
*digest
= (u32
*) hash_buf
->digest
;
15489 salt_t
*salt
= hash_buf
->salt
;
15491 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15497 char *version_pos
= input_buf
+ 8 + 1;
15499 char *spinCount_pos
= strchr (version_pos
, '*');
15501 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 u32 version_len
= spinCount_pos
- version_pos
;
15505 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15509 char *keySize_pos
= strchr (spinCount_pos
, '*');
15511 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15513 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15515 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15519 char *saltSize_pos
= strchr (keySize_pos
, '*');
15521 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15523 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15525 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15529 char *osalt_pos
= strchr (saltSize_pos
, '*');
15531 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15533 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15535 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15539 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15541 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15543 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15545 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15547 encryptedVerifier_pos
++;
15549 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15551 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15553 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15555 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15557 encryptedVerifierHash_pos
++;
15559 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;
15561 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15563 const uint version
= atoi (version_pos
);
15565 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15567 const uint spinCount
= atoi (spinCount_pos
);
15569 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15571 const uint keySize
= atoi (keySize_pos
);
15573 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15575 const uint saltSize
= atoi (saltSize_pos
);
15577 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15583 salt
->salt_len
= 16;
15584 salt
->salt_iter
= spinCount
;
15586 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15587 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15588 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15589 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15595 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15596 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15597 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15598 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15600 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15601 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15602 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15603 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15604 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15605 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15606 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15607 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15613 digest
[0] = office2013
->encryptedVerifierHash
[0];
15614 digest
[1] = office2013
->encryptedVerifierHash
[1];
15615 digest
[2] = office2013
->encryptedVerifierHash
[2];
15616 digest
[3] = office2013
->encryptedVerifierHash
[3];
15618 return (PARSER_OK
);
15621 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15623 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15625 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15627 u32
*digest
= (u32
*) hash_buf
->digest
;
15629 salt_t
*salt
= hash_buf
->salt
;
15631 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15637 char *version_pos
= input_buf
+ 11;
15639 char *osalt_pos
= strchr (version_pos
, '*');
15641 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15643 u32 version_len
= osalt_pos
- version_pos
;
15645 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15649 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15651 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15653 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15655 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15657 encryptedVerifier_pos
++;
15659 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15661 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15663 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15665 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15667 encryptedVerifierHash_pos
++;
15669 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15671 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15673 const uint version
= *version_pos
- 0x30;
15675 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15681 oldoffice01
->version
= version
;
15683 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15684 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15685 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15686 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15688 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15689 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15690 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15691 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15693 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15694 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15695 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15696 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15698 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15699 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15700 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15701 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15707 salt
->salt_len
= 16;
15709 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15710 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15711 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15712 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15714 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15715 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15716 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15717 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15719 // this is a workaround as office produces multiple documents with the same salt
15721 salt
->salt_len
+= 32;
15723 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15724 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15725 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15726 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15727 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15728 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15729 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15730 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15736 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15737 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15738 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15739 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15741 return (PARSER_OK
);
15744 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15746 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15749 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15751 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15753 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15755 u32
*digest
= (u32
*) hash_buf
->digest
;
15757 salt_t
*salt
= hash_buf
->salt
;
15759 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15765 char *version_pos
= input_buf
+ 11;
15767 char *osalt_pos
= strchr (version_pos
, '*');
15769 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 u32 version_len
= osalt_pos
- version_pos
;
15773 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15777 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15779 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15781 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15783 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15785 encryptedVerifier_pos
++;
15787 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15789 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15791 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15793 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15795 encryptedVerifierHash_pos
++;
15797 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15799 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15801 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15803 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15807 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15809 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15811 const uint version
= *version_pos
- 0x30;
15813 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15819 oldoffice01
->version
= version
;
15821 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15822 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15823 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15824 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15826 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15827 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15828 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15829 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15831 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15832 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15833 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15834 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15836 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15837 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15838 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15839 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15841 oldoffice01
->rc4key
[1] = 0;
15842 oldoffice01
->rc4key
[0] = 0;
15844 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15845 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15846 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15847 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15848 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15849 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15850 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15851 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15852 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15853 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15855 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15856 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15862 salt
->salt_len
= 16;
15864 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15865 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15866 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15867 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15869 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15870 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15871 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15872 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15874 // this is a workaround as office produces multiple documents with the same salt
15876 salt
->salt_len
+= 32;
15878 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15879 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15880 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15881 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15882 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15883 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15884 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15885 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15891 digest
[0] = oldoffice01
->rc4key
[0];
15892 digest
[1] = oldoffice01
->rc4key
[1];
15896 return (PARSER_OK
);
15899 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15901 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15903 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15905 u32
*digest
= (u32
*) hash_buf
->digest
;
15907 salt_t
*salt
= hash_buf
->salt
;
15909 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15915 char *version_pos
= input_buf
+ 11;
15917 char *osalt_pos
= strchr (version_pos
, '*');
15919 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15921 u32 version_len
= osalt_pos
- version_pos
;
15923 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15927 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15929 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15931 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15933 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15935 encryptedVerifier_pos
++;
15937 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15939 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15941 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15943 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15945 encryptedVerifierHash_pos
++;
15947 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15949 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15951 const uint version
= *version_pos
- 0x30;
15953 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15959 oldoffice34
->version
= version
;
15961 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15962 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15963 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15964 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15966 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15967 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15968 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15969 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15971 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15972 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15973 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15974 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15975 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15977 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15978 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15979 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15980 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15981 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15987 salt
->salt_len
= 16;
15989 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15990 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15991 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15992 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15994 // this is a workaround as office produces multiple documents with the same salt
15996 salt
->salt_len
+= 32;
15998 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15999 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16000 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16001 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16002 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16003 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16004 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16005 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16011 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16012 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16013 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16014 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16016 return (PARSER_OK
);
16019 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16021 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16023 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16026 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16028 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16030 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16032 u32
*digest
= (u32
*) hash_buf
->digest
;
16034 salt_t
*salt
= hash_buf
->salt
;
16036 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16042 char *version_pos
= input_buf
+ 11;
16044 char *osalt_pos
= strchr (version_pos
, '*');
16046 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16048 u32 version_len
= osalt_pos
- version_pos
;
16050 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16054 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16056 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16058 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16060 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16062 encryptedVerifier_pos
++;
16064 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16066 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16068 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16070 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16072 encryptedVerifierHash_pos
++;
16074 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16076 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16078 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16080 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16084 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16086 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16088 const uint version
= *version_pos
- 0x30;
16090 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16096 oldoffice34
->version
= version
;
16098 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16099 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16100 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16101 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16103 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16104 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16105 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16106 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16108 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16109 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16110 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16111 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16112 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16114 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16115 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16116 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16117 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16118 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16120 oldoffice34
->rc4key
[1] = 0;
16121 oldoffice34
->rc4key
[0] = 0;
16123 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16124 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16125 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16126 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16127 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16128 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16129 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16130 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16131 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16132 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16134 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16135 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16141 salt
->salt_len
= 16;
16143 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16144 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16145 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16146 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16148 // this is a workaround as office produces multiple documents with the same salt
16150 salt
->salt_len
+= 32;
16152 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16153 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16154 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16155 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16156 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16157 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16158 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16159 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16165 digest
[0] = oldoffice34
->rc4key
[0];
16166 digest
[1] = oldoffice34
->rc4key
[1];
16170 return (PARSER_OK
);
16173 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16175 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16177 u32
*digest
= (u32
*) hash_buf
->digest
;
16179 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16180 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16181 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16182 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16184 digest
[0] = byte_swap_32 (digest
[0]);
16185 digest
[1] = byte_swap_32 (digest
[1]);
16186 digest
[2] = byte_swap_32 (digest
[2]);
16187 digest
[3] = byte_swap_32 (digest
[3]);
16189 return (PARSER_OK
);
16192 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16194 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16196 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16198 u32
*digest
= (u32
*) hash_buf
->digest
;
16200 salt_t
*salt
= hash_buf
->salt
;
16202 char *signature_pos
= input_buf
;
16204 char *salt_pos
= strchr (signature_pos
, '$');
16206 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16208 u32 signature_len
= salt_pos
- signature_pos
;
16210 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16214 char *hash_pos
= strchr (salt_pos
, '$');
16216 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16218 u32 salt_len
= hash_pos
- salt_pos
;
16220 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16224 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16226 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16228 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16229 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16230 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16231 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16232 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16234 digest
[0] -= SHA1M_A
;
16235 digest
[1] -= SHA1M_B
;
16236 digest
[2] -= SHA1M_C
;
16237 digest
[3] -= SHA1M_D
;
16238 digest
[4] -= SHA1M_E
;
16240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16242 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16244 salt
->salt_len
= salt_len
;
16246 return (PARSER_OK
);
16249 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16251 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16253 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16255 u32
*digest
= (u32
*) hash_buf
->digest
;
16257 salt_t
*salt
= hash_buf
->salt
;
16259 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16265 char *iter_pos
= input_buf
+ 14;
16267 const int iter
= atoi (iter_pos
);
16269 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16271 salt
->salt_iter
= iter
- 1;
16273 char *salt_pos
= strchr (iter_pos
, '$');
16275 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16279 char *hash_pos
= strchr (salt_pos
, '$');
16281 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16283 const uint salt_len
= hash_pos
- salt_pos
;
16287 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16289 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16291 salt
->salt_len
= salt_len
;
16293 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16294 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16296 // add some stuff to normal salt to make sorted happy
16298 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16299 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16300 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16301 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16302 salt
->salt_buf
[4] = salt
->salt_iter
;
16304 // base64 decode hash
16306 u8 tmp_buf
[100] = { 0 };
16308 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16310 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16312 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16314 memcpy (digest
, tmp_buf
, 32);
16316 digest
[0] = byte_swap_32 (digest
[0]);
16317 digest
[1] = byte_swap_32 (digest
[1]);
16318 digest
[2] = byte_swap_32 (digest
[2]);
16319 digest
[3] = byte_swap_32 (digest
[3]);
16320 digest
[4] = byte_swap_32 (digest
[4]);
16321 digest
[5] = byte_swap_32 (digest
[5]);
16322 digest
[6] = byte_swap_32 (digest
[6]);
16323 digest
[7] = byte_swap_32 (digest
[7]);
16325 return (PARSER_OK
);
16328 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16330 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16332 u32
*digest
= (u32
*) hash_buf
->digest
;
16334 salt_t
*salt
= hash_buf
->salt
;
16336 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16337 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16341 digest
[0] = byte_swap_32 (digest
[0]);
16342 digest
[1] = byte_swap_32 (digest
[1]);
16344 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16345 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16346 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16348 char iter_c
= input_buf
[17];
16349 char iter_d
= input_buf
[19];
16351 // atm only defaults, let's see if there's more request
16352 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16353 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16355 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16357 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16358 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16359 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16360 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16362 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16363 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16364 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16365 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16367 salt
->salt_len
= 16;
16369 return (PARSER_OK
);
16372 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16374 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16376 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16378 u32
*digest
= (u32
*) hash_buf
->digest
;
16380 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16382 salt_t
*salt
= hash_buf
->salt
;
16384 char *salt_pos
= input_buf
+ 10;
16386 char *hash_pos
= strchr (salt_pos
, '$');
16388 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 uint salt_len
= hash_pos
- salt_pos
;
16394 uint hash_len
= input_len
- 10 - salt_len
- 1;
16396 // base64 decode salt
16398 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16400 u8 tmp_buf
[100] = { 0 };
16402 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16404 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16406 tmp_buf
[salt_len
] = 0x80;
16408 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16410 salt
->salt_len
= salt_len
;
16412 // base64 decode hash
16414 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16416 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16418 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16420 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16422 uint user_len
= hash_len
- 32;
16424 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16426 user_len
--; // skip the trailing space
16428 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16429 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16430 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16431 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16433 digest
[0] = byte_swap_32 (digest
[0]);
16434 digest
[1] = byte_swap_32 (digest
[1]);
16435 digest
[2] = byte_swap_32 (digest
[2]);
16436 digest
[3] = byte_swap_32 (digest
[3]);
16438 // store username for host only (output hash if cracked)
16440 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16441 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16443 return (PARSER_OK
);
16446 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16448 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16450 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16452 u32
*digest
= (u32
*) hash_buf
->digest
;
16454 salt_t
*salt
= hash_buf
->salt
;
16456 char *iter_pos
= input_buf
+ 10;
16458 u32 iter
= atoi (iter_pos
);
16462 return (PARSER_SALT_ITERATION
);
16465 iter
--; // first iteration is special
16467 salt
->salt_iter
= iter
;
16469 char *base64_pos
= strchr (iter_pos
, '}');
16471 if (base64_pos
== NULL
)
16473 return (PARSER_SIGNATURE_UNMATCHED
);
16478 // base64 decode salt
16480 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16482 u8 tmp_buf
[100] = { 0 };
16484 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16486 if (decoded_len
< 24)
16488 return (PARSER_SALT_LENGTH
);
16493 uint salt_len
= decoded_len
- 20;
16495 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16496 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16498 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16500 salt
->salt_len
= salt_len
;
16504 u32
*digest_ptr
= (u32
*) tmp_buf
;
16506 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16507 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16508 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16509 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16510 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16512 return (PARSER_OK
);
16515 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16517 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16519 u32
*digest
= (u32
*) hash_buf
->digest
;
16521 salt_t
*salt
= hash_buf
->salt
;
16523 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16524 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16525 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16526 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16527 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16529 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16531 uint salt_len
= input_len
- 40 - 1;
16533 char *salt_buf
= input_buf
+ 40 + 1;
16535 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16537 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16539 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16541 salt
->salt_len
= salt_len
;
16543 return (PARSER_OK
);
16546 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16548 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16550 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16552 u32
*digest
= (u32
*) hash_buf
->digest
;
16554 salt_t
*salt
= hash_buf
->salt
;
16556 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16562 char *V_pos
= input_buf
+ 5;
16564 char *R_pos
= strchr (V_pos
, '*');
16566 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16568 u32 V_len
= R_pos
- V_pos
;
16572 char *bits_pos
= strchr (R_pos
, '*');
16574 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16576 u32 R_len
= bits_pos
- R_pos
;
16580 char *P_pos
= strchr (bits_pos
, '*');
16582 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16584 u32 bits_len
= P_pos
- bits_pos
;
16588 char *enc_md_pos
= strchr (P_pos
, '*');
16590 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16592 u32 P_len
= enc_md_pos
- P_pos
;
16596 char *id_len_pos
= strchr (enc_md_pos
, '*');
16598 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16600 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16604 char *id_buf_pos
= strchr (id_len_pos
, '*');
16606 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16608 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16612 char *u_len_pos
= strchr (id_buf_pos
, '*');
16614 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16616 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16618 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16622 char *u_buf_pos
= strchr (u_len_pos
, '*');
16624 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16626 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16630 char *o_len_pos
= strchr (u_buf_pos
, '*');
16632 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16634 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16636 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16640 char *o_buf_pos
= strchr (o_len_pos
, '*');
16642 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16644 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16648 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;
16650 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16654 const int V
= atoi (V_pos
);
16655 const int R
= atoi (R_pos
);
16656 const int P
= atoi (P_pos
);
16658 if (V
!= 1) return (PARSER_SALT_VALUE
);
16659 if (R
!= 2) return (PARSER_SALT_VALUE
);
16661 const int enc_md
= atoi (enc_md_pos
);
16663 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16665 const int id_len
= atoi (id_len_pos
);
16666 const int u_len
= atoi (u_len_pos
);
16667 const int o_len
= atoi (o_len_pos
);
16669 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16670 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16671 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16673 const int bits
= atoi (bits_pos
);
16675 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16677 // copy data to esalt
16683 pdf
->enc_md
= enc_md
;
16685 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16686 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16687 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16688 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16689 pdf
->id_len
= id_len
;
16691 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16692 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16693 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16694 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16695 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16696 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16697 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16698 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16699 pdf
->u_len
= u_len
;
16701 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16702 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16703 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16704 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16705 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16706 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16707 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16708 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16709 pdf
->o_len
= o_len
;
16711 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16712 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16713 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16714 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16716 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16717 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16718 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16719 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16720 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16721 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16722 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16723 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16725 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16726 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16727 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16728 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16729 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16730 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16731 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16732 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16734 // we use ID for salt, maybe needs to change, we will see...
16736 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16737 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16738 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16739 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16740 salt
->salt_len
= pdf
->id_len
;
16742 digest
[0] = pdf
->u_buf
[0];
16743 digest
[1] = pdf
->u_buf
[1];
16744 digest
[2] = pdf
->u_buf
[2];
16745 digest
[3] = pdf
->u_buf
[3];
16747 return (PARSER_OK
);
16750 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16752 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16755 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16757 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16759 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16761 u32
*digest
= (u32
*) hash_buf
->digest
;
16763 salt_t
*salt
= hash_buf
->salt
;
16765 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16771 char *V_pos
= input_buf
+ 5;
16773 char *R_pos
= strchr (V_pos
, '*');
16775 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16777 u32 V_len
= R_pos
- V_pos
;
16781 char *bits_pos
= strchr (R_pos
, '*');
16783 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16785 u32 R_len
= bits_pos
- R_pos
;
16789 char *P_pos
= strchr (bits_pos
, '*');
16791 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16793 u32 bits_len
= P_pos
- bits_pos
;
16797 char *enc_md_pos
= strchr (P_pos
, '*');
16799 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16801 u32 P_len
= enc_md_pos
- P_pos
;
16805 char *id_len_pos
= strchr (enc_md_pos
, '*');
16807 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16809 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16813 char *id_buf_pos
= strchr (id_len_pos
, '*');
16815 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16817 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16821 char *u_len_pos
= strchr (id_buf_pos
, '*');
16823 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16825 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16827 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16831 char *u_buf_pos
= strchr (u_len_pos
, '*');
16833 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16835 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16839 char *o_len_pos
= strchr (u_buf_pos
, '*');
16841 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16843 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16845 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16849 char *o_buf_pos
= strchr (o_len_pos
, '*');
16851 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16853 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16857 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16859 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16861 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16863 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16867 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;
16869 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16873 const int V
= atoi (V_pos
);
16874 const int R
= atoi (R_pos
);
16875 const int P
= atoi (P_pos
);
16877 if (V
!= 1) return (PARSER_SALT_VALUE
);
16878 if (R
!= 2) return (PARSER_SALT_VALUE
);
16880 const int enc_md
= atoi (enc_md_pos
);
16882 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16884 const int id_len
= atoi (id_len_pos
);
16885 const int u_len
= atoi (u_len_pos
);
16886 const int o_len
= atoi (o_len_pos
);
16888 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16889 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16890 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16892 const int bits
= atoi (bits_pos
);
16894 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16896 // copy data to esalt
16902 pdf
->enc_md
= enc_md
;
16904 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16905 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16906 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16907 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16908 pdf
->id_len
= id_len
;
16910 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16911 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16912 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16913 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16914 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16915 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16916 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16917 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16918 pdf
->u_len
= u_len
;
16920 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16921 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16922 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16923 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16924 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16925 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16926 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16927 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16928 pdf
->o_len
= o_len
;
16930 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16931 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16932 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16933 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16935 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16936 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16937 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16938 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16939 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16940 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16941 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16942 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16944 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16945 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16946 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16947 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16948 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16949 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16950 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16951 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16953 pdf
->rc4key
[1] = 0;
16954 pdf
->rc4key
[0] = 0;
16956 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16957 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16958 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16959 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16960 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16961 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16962 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16963 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16964 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16965 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16967 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16968 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16970 // we use ID for salt, maybe needs to change, we will see...
16972 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16973 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16974 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16975 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16976 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16977 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16978 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16979 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16980 salt
->salt_len
= pdf
->id_len
+ 16;
16982 digest
[0] = pdf
->rc4key
[0];
16983 digest
[1] = pdf
->rc4key
[1];
16987 return (PARSER_OK
);
16990 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16992 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16994 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16996 u32
*digest
= (u32
*) hash_buf
->digest
;
16998 salt_t
*salt
= hash_buf
->salt
;
17000 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17006 char *V_pos
= input_buf
+ 5;
17008 char *R_pos
= strchr (V_pos
, '*');
17010 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17012 u32 V_len
= R_pos
- V_pos
;
17016 char *bits_pos
= strchr (R_pos
, '*');
17018 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17020 u32 R_len
= bits_pos
- R_pos
;
17024 char *P_pos
= strchr (bits_pos
, '*');
17026 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17028 u32 bits_len
= P_pos
- bits_pos
;
17032 char *enc_md_pos
= strchr (P_pos
, '*');
17034 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17036 u32 P_len
= enc_md_pos
- P_pos
;
17040 char *id_len_pos
= strchr (enc_md_pos
, '*');
17042 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17044 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17048 char *id_buf_pos
= strchr (id_len_pos
, '*');
17050 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17056 char *u_len_pos
= strchr (id_buf_pos
, '*');
17058 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17060 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17062 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17066 char *u_buf_pos
= strchr (u_len_pos
, '*');
17068 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17074 char *o_len_pos
= strchr (u_buf_pos
, '*');
17076 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17078 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17080 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17084 char *o_buf_pos
= strchr (o_len_pos
, '*');
17086 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17088 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17092 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;
17094 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17098 const int V
= atoi (V_pos
);
17099 const int R
= atoi (R_pos
);
17100 const int P
= atoi (P_pos
);
17104 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17105 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17107 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17109 const int id_len
= atoi (id_len_pos
);
17110 const int u_len
= atoi (u_len_pos
);
17111 const int o_len
= atoi (o_len_pos
);
17113 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17115 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17116 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17118 const int bits
= atoi (bits_pos
);
17120 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17126 enc_md
= atoi (enc_md_pos
);
17129 // copy data to esalt
17135 pdf
->enc_md
= enc_md
;
17137 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17138 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17139 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17140 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17144 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17145 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17146 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17147 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17150 pdf
->id_len
= id_len
;
17152 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17153 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17154 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17155 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17156 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17157 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17158 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17159 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17160 pdf
->u_len
= u_len
;
17162 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17163 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17164 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17165 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17166 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17167 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17168 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17169 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17170 pdf
->o_len
= o_len
;
17172 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17173 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17174 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17175 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17179 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17180 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17181 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17182 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17185 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17186 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17187 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17188 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17189 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17190 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17191 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17192 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17194 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17195 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17196 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17197 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17198 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17199 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17200 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17201 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17203 // precompute rc4 data for later use
17219 uint salt_pc_block
[32] = { 0 };
17221 char *salt_pc_ptr
= (char *) salt_pc_block
;
17223 memcpy (salt_pc_ptr
, padding
, 32);
17224 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17226 uint salt_pc_digest
[4] = { 0 };
17228 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17230 pdf
->rc4data
[0] = salt_pc_digest
[0];
17231 pdf
->rc4data
[1] = salt_pc_digest
[1];
17233 // we use ID for salt, maybe needs to change, we will see...
17235 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17236 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17237 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17238 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17239 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17240 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17241 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17242 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17243 salt
->salt_len
= pdf
->id_len
+ 16;
17245 salt
->salt_iter
= ROUNDS_PDF14
;
17247 digest
[0] = pdf
->u_buf
[0];
17248 digest
[1] = pdf
->u_buf
[1];
17252 return (PARSER_OK
);
17255 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17257 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17259 if (ret
!= PARSER_OK
)
17264 u32
*digest
= (u32
*) hash_buf
->digest
;
17266 salt_t
*salt
= hash_buf
->salt
;
17268 digest
[0] -= SHA256M_A
;
17269 digest
[1] -= SHA256M_B
;
17270 digest
[2] -= SHA256M_C
;
17271 digest
[3] -= SHA256M_D
;
17272 digest
[4] -= SHA256M_E
;
17273 digest
[5] -= SHA256M_F
;
17274 digest
[6] -= SHA256M_G
;
17275 digest
[7] -= SHA256M_H
;
17277 salt
->salt_buf
[2] = 0x80;
17279 return (PARSER_OK
);
17282 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17284 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17286 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17288 u32
*digest
= (u32
*) hash_buf
->digest
;
17290 salt_t
*salt
= hash_buf
->salt
;
17292 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17298 char *V_pos
= input_buf
+ 5;
17300 char *R_pos
= strchr (V_pos
, '*');
17302 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 u32 V_len
= R_pos
- V_pos
;
17308 char *bits_pos
= strchr (R_pos
, '*');
17310 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17312 u32 R_len
= bits_pos
- R_pos
;
17316 char *P_pos
= strchr (bits_pos
, '*');
17318 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 u32 bits_len
= P_pos
- bits_pos
;
17324 char *enc_md_pos
= strchr (P_pos
, '*');
17326 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 u32 P_len
= enc_md_pos
- P_pos
;
17332 char *id_len_pos
= strchr (enc_md_pos
, '*');
17334 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17336 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17340 char *id_buf_pos
= strchr (id_len_pos
, '*');
17342 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17344 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17348 char *u_len_pos
= strchr (id_buf_pos
, '*');
17350 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17352 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17356 char *u_buf_pos
= strchr (u_len_pos
, '*');
17358 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17364 char *o_len_pos
= strchr (u_buf_pos
, '*');
17366 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17372 char *o_buf_pos
= strchr (o_len_pos
, '*');
17374 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17376 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17380 char *last
= strchr (o_buf_pos
, '*');
17382 if (last
== NULL
) last
= input_buf
+ input_len
;
17384 u32 o_buf_len
= last
- o_buf_pos
;
17388 const int V
= atoi (V_pos
);
17389 const int R
= atoi (R_pos
);
17393 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17394 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17396 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17398 const int bits
= atoi (bits_pos
);
17400 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17402 int enc_md
= atoi (enc_md_pos
);
17404 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17406 const uint id_len
= atoi (id_len_pos
);
17407 const uint u_len
= atoi (u_len_pos
);
17408 const uint o_len
= atoi (o_len_pos
);
17410 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17411 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17412 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17413 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17414 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17415 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17416 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17417 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17419 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17420 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17421 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17423 // copy data to esalt
17425 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17427 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17429 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17432 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17433 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17435 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17436 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17438 salt
->salt_len
= 8;
17439 salt
->salt_iter
= ROUNDS_PDF17L8
;
17441 digest
[0] = pdf
->u_buf
[0];
17442 digest
[1] = pdf
->u_buf
[1];
17443 digest
[2] = pdf
->u_buf
[2];
17444 digest
[3] = pdf
->u_buf
[3];
17445 digest
[4] = pdf
->u_buf
[4];
17446 digest
[5] = pdf
->u_buf
[5];
17447 digest
[6] = pdf
->u_buf
[6];
17448 digest
[7] = pdf
->u_buf
[7];
17450 return (PARSER_OK
);
17453 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17455 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17457 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17459 u32
*digest
= (u32
*) hash_buf
->digest
;
17461 salt_t
*salt
= hash_buf
->salt
;
17463 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17471 char *iter_pos
= input_buf
+ 7;
17473 u32 iter
= atoi (iter_pos
);
17475 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17476 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17478 // first is *raw* salt
17480 char *salt_pos
= strchr (iter_pos
, ':');
17482 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17486 char *hash_pos
= strchr (salt_pos
, ':');
17488 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17490 u32 salt_len
= hash_pos
- salt_pos
;
17492 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17496 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17498 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17502 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17504 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17506 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17508 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17509 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17511 salt
->salt_len
= salt_len
;
17512 salt
->salt_iter
= iter
- 1;
17516 u8 tmp_buf
[100] = { 0 };
17518 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17520 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17522 memcpy (digest
, tmp_buf
, 16);
17524 digest
[0] = byte_swap_32 (digest
[0]);
17525 digest
[1] = byte_swap_32 (digest
[1]);
17526 digest
[2] = byte_swap_32 (digest
[2]);
17527 digest
[3] = byte_swap_32 (digest
[3]);
17529 // add some stuff to normal salt to make sorted happy
17531 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17532 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17533 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17534 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17535 salt
->salt_buf
[4] = salt
->salt_iter
;
17537 return (PARSER_OK
);
17540 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17542 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17544 u32
*digest
= (u32
*) hash_buf
->digest
;
17546 salt_t
*salt
= hash_buf
->salt
;
17548 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17549 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17550 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17551 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17553 digest
[0] = byte_swap_32 (digest
[0]);
17554 digest
[1] = byte_swap_32 (digest
[1]);
17555 digest
[2] = byte_swap_32 (digest
[2]);
17556 digest
[3] = byte_swap_32 (digest
[3]);
17558 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17560 uint salt_len
= input_len
- 32 - 1;
17562 char *salt_buf
= input_buf
+ 32 + 1;
17564 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17566 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17568 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17570 salt
->salt_len
= salt_len
;
17572 return (PARSER_OK
);
17575 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17577 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17579 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17581 u32
*digest
= (u32
*) hash_buf
->digest
;
17583 salt_t
*salt
= hash_buf
->salt
;
17585 char *user_pos
= input_buf
+ 10;
17587 char *salt_pos
= strchr (user_pos
, '*');
17589 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17593 char *hash_pos
= strchr (salt_pos
, '*');
17597 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17599 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17601 uint user_len
= salt_pos
- user_pos
- 1;
17603 uint salt_len
= hash_pos
- salt_pos
- 1;
17605 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17611 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17612 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17613 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17614 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17616 digest
[0] = byte_swap_32 (digest
[0]);
17617 digest
[1] = byte_swap_32 (digest
[1]);
17618 digest
[2] = byte_swap_32 (digest
[2]);
17619 digest
[3] = byte_swap_32 (digest
[3]);
17621 digest
[0] -= MD5M_A
;
17622 digest
[1] -= MD5M_B
;
17623 digest
[2] -= MD5M_C
;
17624 digest
[3] -= MD5M_D
;
17630 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17632 // first 4 bytes are the "challenge"
17634 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17635 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17636 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17637 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17639 // append the user name
17641 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17643 salt
->salt_len
= 4 + user_len
;
17645 return (PARSER_OK
);
17648 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17650 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17652 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17654 u32
*digest
= (u32
*) hash_buf
->digest
;
17656 salt_t
*salt
= hash_buf
->salt
;
17658 char *salt_pos
= input_buf
+ 9;
17660 char *hash_pos
= strchr (salt_pos
, '*');
17662 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17666 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17668 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17670 uint salt_len
= hash_pos
- salt_pos
- 1;
17672 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17678 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17679 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17680 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17681 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17682 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17688 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17690 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17692 salt
->salt_len
= salt_len
;
17694 return (PARSER_OK
);
17697 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17699 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17701 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17703 u32
*digest
= (u32
*) hash_buf
->digest
;
17705 salt_t
*salt
= hash_buf
->salt
;
17707 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17713 char *cry_master_len_pos
= input_buf
+ 9;
17715 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17717 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17719 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17721 cry_master_buf_pos
++;
17723 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17725 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17727 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17729 cry_salt_len_pos
++;
17731 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17733 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17735 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17737 cry_salt_buf_pos
++;
17739 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17741 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17743 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17747 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17749 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17751 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17755 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17757 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17759 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17763 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17765 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17767 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17769 public_key_len_pos
++;
17771 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17773 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17775 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17777 public_key_buf_pos
++;
17779 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;
17781 const uint cry_master_len
= atoi (cry_master_len_pos
);
17782 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17783 const uint ckey_len
= atoi (ckey_len_pos
);
17784 const uint public_key_len
= atoi (public_key_len_pos
);
17786 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17787 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17788 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17789 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17791 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17793 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17795 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17798 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17800 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17802 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17805 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17807 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17809 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17812 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17813 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17814 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17817 * store digest (should be unique enought, hopefully)
17820 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17821 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17822 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17823 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17829 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17831 const uint cry_rounds
= atoi (cry_rounds_pos
);
17833 salt
->salt_iter
= cry_rounds
- 1;
17835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17837 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17839 salt
->salt_len
= salt_len
;
17841 return (PARSER_OK
);
17844 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17846 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17848 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17850 u32
*digest
= (u32
*) hash_buf
->digest
;
17852 salt_t
*salt
= hash_buf
->salt
;
17854 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17856 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17858 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17860 memcpy (temp_input_buf
, input_buf
, input_len
);
17864 char *URI_server_pos
= temp_input_buf
+ 6;
17866 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17868 if (URI_client_pos
== NULL
)
17870 myfree (temp_input_buf
);
17872 return (PARSER_SEPARATOR_UNMATCHED
);
17875 URI_client_pos
[0] = 0;
17878 uint URI_server_len
= strlen (URI_server_pos
);
17880 if (URI_server_len
> 512)
17882 myfree (temp_input_buf
);
17884 return (PARSER_SALT_LENGTH
);
17889 char *user_pos
= strchr (URI_client_pos
, '*');
17891 if (user_pos
== NULL
)
17893 myfree (temp_input_buf
);
17895 return (PARSER_SEPARATOR_UNMATCHED
);
17901 uint URI_client_len
= strlen (URI_client_pos
);
17903 if (URI_client_len
> 512)
17905 myfree (temp_input_buf
);
17907 return (PARSER_SALT_LENGTH
);
17912 char *realm_pos
= strchr (user_pos
, '*');
17914 if (realm_pos
== NULL
)
17916 myfree (temp_input_buf
);
17918 return (PARSER_SEPARATOR_UNMATCHED
);
17924 uint user_len
= strlen (user_pos
);
17926 if (user_len
> 116)
17928 myfree (temp_input_buf
);
17930 return (PARSER_SALT_LENGTH
);
17935 char *method_pos
= strchr (realm_pos
, '*');
17937 if (method_pos
== NULL
)
17939 myfree (temp_input_buf
);
17941 return (PARSER_SEPARATOR_UNMATCHED
);
17947 uint realm_len
= strlen (realm_pos
);
17949 if (realm_len
> 116)
17951 myfree (temp_input_buf
);
17953 return (PARSER_SALT_LENGTH
);
17958 char *URI_prefix_pos
= strchr (method_pos
, '*');
17960 if (URI_prefix_pos
== NULL
)
17962 myfree (temp_input_buf
);
17964 return (PARSER_SEPARATOR_UNMATCHED
);
17967 URI_prefix_pos
[0] = 0;
17970 uint method_len
= strlen (method_pos
);
17972 if (method_len
> 246)
17974 myfree (temp_input_buf
);
17976 return (PARSER_SALT_LENGTH
);
17981 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17983 if (URI_resource_pos
== NULL
)
17985 myfree (temp_input_buf
);
17987 return (PARSER_SEPARATOR_UNMATCHED
);
17990 URI_resource_pos
[0] = 0;
17991 URI_resource_pos
++;
17993 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17995 if (URI_prefix_len
> 245)
17997 myfree (temp_input_buf
);
17999 return (PARSER_SALT_LENGTH
);
18004 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18006 if (URI_suffix_pos
== NULL
)
18008 myfree (temp_input_buf
);
18010 return (PARSER_SEPARATOR_UNMATCHED
);
18013 URI_suffix_pos
[0] = 0;
18016 uint URI_resource_len
= strlen (URI_resource_pos
);
18018 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18020 myfree (temp_input_buf
);
18022 return (PARSER_SALT_LENGTH
);
18027 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18029 if (nonce_pos
== NULL
)
18031 myfree (temp_input_buf
);
18033 return (PARSER_SEPARATOR_UNMATCHED
);
18039 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18041 if (URI_suffix_len
> 245)
18043 myfree (temp_input_buf
);
18045 return (PARSER_SALT_LENGTH
);
18050 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18052 if (nonce_client_pos
== NULL
)
18054 myfree (temp_input_buf
);
18056 return (PARSER_SEPARATOR_UNMATCHED
);
18059 nonce_client_pos
[0] = 0;
18060 nonce_client_pos
++;
18062 uint nonce_len
= strlen (nonce_pos
);
18064 if (nonce_len
< 1 || nonce_len
> 50)
18066 myfree (temp_input_buf
);
18068 return (PARSER_SALT_LENGTH
);
18073 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18075 if (nonce_count_pos
== NULL
)
18077 myfree (temp_input_buf
);
18079 return (PARSER_SEPARATOR_UNMATCHED
);
18082 nonce_count_pos
[0] = 0;
18085 uint nonce_client_len
= strlen (nonce_client_pos
);
18087 if (nonce_client_len
> 50)
18089 myfree (temp_input_buf
);
18091 return (PARSER_SALT_LENGTH
);
18096 char *qop_pos
= strchr (nonce_count_pos
, '*');
18098 if (qop_pos
== NULL
)
18100 myfree (temp_input_buf
);
18102 return (PARSER_SEPARATOR_UNMATCHED
);
18108 uint nonce_count_len
= strlen (nonce_count_pos
);
18110 if (nonce_count_len
> 50)
18112 myfree (temp_input_buf
);
18114 return (PARSER_SALT_LENGTH
);
18119 char *directive_pos
= strchr (qop_pos
, '*');
18121 if (directive_pos
== NULL
)
18123 myfree (temp_input_buf
);
18125 return (PARSER_SEPARATOR_UNMATCHED
);
18128 directive_pos
[0] = 0;
18131 uint qop_len
= strlen (qop_pos
);
18135 myfree (temp_input_buf
);
18137 return (PARSER_SALT_LENGTH
);
18142 char *digest_pos
= strchr (directive_pos
, '*');
18144 if (digest_pos
== NULL
)
18146 myfree (temp_input_buf
);
18148 return (PARSER_SEPARATOR_UNMATCHED
);
18154 uint directive_len
= strlen (directive_pos
);
18156 if (directive_len
!= 3)
18158 myfree (temp_input_buf
);
18160 return (PARSER_SALT_LENGTH
);
18163 if (memcmp (directive_pos
, "MD5", 3))
18165 log_info ("ERROR: only the MD5 directive is currently supported\n");
18167 myfree (temp_input_buf
);
18169 return (PARSER_SIP_AUTH_DIRECTIVE
);
18173 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18178 uint md5_max_len
= 4 * 64;
18180 uint md5_remaining_len
= md5_max_len
;
18182 uint tmp_md5_buf
[64] = { 0 };
18184 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18186 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18188 md5_len
+= method_len
+ 1;
18189 tmp_md5_ptr
+= method_len
+ 1;
18191 if (URI_prefix_len
> 0)
18193 md5_remaining_len
= md5_max_len
- md5_len
;
18195 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18197 md5_len
+= URI_prefix_len
+ 1;
18198 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18201 md5_remaining_len
= md5_max_len
- md5_len
;
18203 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18205 md5_len
+= URI_resource_len
;
18206 tmp_md5_ptr
+= URI_resource_len
;
18208 if (URI_suffix_len
> 0)
18210 md5_remaining_len
= md5_max_len
- md5_len
;
18212 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18214 md5_len
+= 1 + URI_suffix_len
;
18217 uint tmp_digest
[4] = { 0 };
18219 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18221 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18222 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18223 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18224 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18230 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18232 uint esalt_len
= 0;
18234 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18236 // there are 2 possibilities for the esalt:
18238 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18240 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18242 if (esalt_len
> max_esalt_len
)
18244 myfree (temp_input_buf
);
18246 return (PARSER_SALT_LENGTH
);
18249 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18261 esalt_len
= 1 + nonce_len
+ 1 + 32;
18263 if (esalt_len
> max_esalt_len
)
18265 myfree (temp_input_buf
);
18267 return (PARSER_SALT_LENGTH
);
18270 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18278 // add 0x80 to esalt
18280 esalt_buf_ptr
[esalt_len
] = 0x80;
18282 sip
->esalt_len
= esalt_len
;
18288 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18290 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18292 uint max_salt_len
= 119;
18294 if (salt_len
> max_salt_len
)
18296 myfree (temp_input_buf
);
18298 return (PARSER_SALT_LENGTH
);
18301 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18303 sip
->salt_len
= salt_len
;
18306 * fake salt (for sorting)
18309 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18313 uint fake_salt_len
= salt_len
;
18315 if (fake_salt_len
> max_salt_len
)
18317 fake_salt_len
= max_salt_len
;
18320 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18322 salt
->salt_len
= fake_salt_len
;
18328 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18329 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18330 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18331 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18333 digest
[0] = byte_swap_32 (digest
[0]);
18334 digest
[1] = byte_swap_32 (digest
[1]);
18335 digest
[2] = byte_swap_32 (digest
[2]);
18336 digest
[3] = byte_swap_32 (digest
[3]);
18338 myfree (temp_input_buf
);
18340 return (PARSER_OK
);
18343 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18345 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18347 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18349 u32
*digest
= (u32
*) hash_buf
->digest
;
18351 salt_t
*salt
= hash_buf
->salt
;
18355 char *digest_pos
= input_buf
;
18357 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18364 char *salt_buf
= input_buf
+ 8 + 1;
18368 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18370 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18372 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18374 salt
->salt_len
= salt_len
;
18376 return (PARSER_OK
);
18379 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18381 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18383 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18385 u32
*digest
= (u32
*) hash_buf
->digest
;
18387 salt_t
*salt
= hash_buf
->salt
;
18389 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18395 char *p_buf_pos
= input_buf
+ 4;
18397 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18399 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18401 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18403 NumCyclesPower_pos
++;
18405 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18407 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18409 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18413 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18415 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18417 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18421 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18423 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18425 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18429 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18431 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18433 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18437 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18439 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18441 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18445 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18447 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18449 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18453 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18455 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18457 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18461 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18463 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18465 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18469 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;
18471 const uint iter
= atoi (NumCyclesPower_pos
);
18472 const uint crc
= atoi (crc_buf_pos
);
18473 const uint p_buf
= atoi (p_buf_pos
);
18474 const uint salt_len
= atoi (salt_len_pos
);
18475 const uint iv_len
= atoi (iv_len_pos
);
18476 const uint unpack_size
= atoi (unpack_size_pos
);
18477 const uint data_len
= atoi (data_len_pos
);
18483 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18484 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18486 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18488 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18490 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18496 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18497 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18498 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18499 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18501 seven_zip
->iv_len
= iv_len
;
18503 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18505 seven_zip
->salt_len
= 0;
18507 seven_zip
->crc
= crc
;
18509 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18511 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18513 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18516 seven_zip
->data_len
= data_len
;
18518 seven_zip
->unpack_size
= unpack_size
;
18522 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18523 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18524 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18525 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18527 salt
->salt_len
= 16;
18529 salt
->salt_sign
[0] = iter
;
18531 salt
->salt_iter
= 1 << iter
;
18542 return (PARSER_OK
);
18545 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18547 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18549 u32
*digest
= (u32
*) hash_buf
->digest
;
18551 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18552 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18553 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18554 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18555 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18556 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18557 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18558 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18560 digest
[0] = byte_swap_32 (digest
[0]);
18561 digest
[1] = byte_swap_32 (digest
[1]);
18562 digest
[2] = byte_swap_32 (digest
[2]);
18563 digest
[3] = byte_swap_32 (digest
[3]);
18564 digest
[4] = byte_swap_32 (digest
[4]);
18565 digest
[5] = byte_swap_32 (digest
[5]);
18566 digest
[6] = byte_swap_32 (digest
[6]);
18567 digest
[7] = byte_swap_32 (digest
[7]);
18569 return (PARSER_OK
);
18572 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18574 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18576 u32
*digest
= (u32
*) hash_buf
->digest
;
18578 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18579 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18580 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18581 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18582 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18583 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18584 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18585 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18586 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18587 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18588 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18589 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18590 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18591 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18592 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18593 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18595 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18596 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18597 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18598 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18599 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18600 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18601 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18602 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18603 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18604 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18605 digest
[10] = byte_swap_32 (digest
[10]);
18606 digest
[11] = byte_swap_32 (digest
[11]);
18607 digest
[12] = byte_swap_32 (digest
[12]);
18608 digest
[13] = byte_swap_32 (digest
[13]);
18609 digest
[14] = byte_swap_32 (digest
[14]);
18610 digest
[15] = byte_swap_32 (digest
[15]);
18612 return (PARSER_OK
);
18615 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18617 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18619 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18621 u32
*digest
= (u32
*) hash_buf
->digest
;
18623 salt_t
*salt
= hash_buf
->salt
;
18625 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18633 char *iter_pos
= input_buf
+ 4;
18635 u32 iter
= atoi (iter_pos
);
18637 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18638 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18640 // first is *raw* salt
18642 char *salt_pos
= strchr (iter_pos
, ':');
18644 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18648 char *hash_pos
= strchr (salt_pos
, ':');
18650 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18652 u32 salt_len
= hash_pos
- salt_pos
;
18654 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18658 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18660 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18664 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18666 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18668 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18670 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18671 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18673 salt
->salt_len
= salt_len
;
18674 salt
->salt_iter
= iter
- 1;
18678 u8 tmp_buf
[100] = { 0 };
18680 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18682 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18684 memcpy (digest
, tmp_buf
, 16);
18686 // add some stuff to normal salt to make sorted happy
18688 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18689 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18690 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18691 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18692 salt
->salt_buf
[4] = salt
->salt_iter
;
18694 return (PARSER_OK
);
18697 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18699 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18701 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18703 u32
*digest
= (u32
*) hash_buf
->digest
;
18705 salt_t
*salt
= hash_buf
->salt
;
18707 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18715 char *iter_pos
= input_buf
+ 5;
18717 u32 iter
= atoi (iter_pos
);
18719 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18720 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18722 // first is *raw* salt
18724 char *salt_pos
= strchr (iter_pos
, ':');
18726 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18730 char *hash_pos
= strchr (salt_pos
, ':');
18732 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18734 u32 salt_len
= hash_pos
- salt_pos
;
18736 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18740 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18742 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18746 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18748 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18750 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18752 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18753 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18755 salt
->salt_len
= salt_len
;
18756 salt
->salt_iter
= iter
- 1;
18760 u8 tmp_buf
[100] = { 0 };
18762 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18764 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18766 memcpy (digest
, tmp_buf
, 16);
18768 digest
[0] = byte_swap_32 (digest
[0]);
18769 digest
[1] = byte_swap_32 (digest
[1]);
18770 digest
[2] = byte_swap_32 (digest
[2]);
18771 digest
[3] = byte_swap_32 (digest
[3]);
18773 // add some stuff to normal salt to make sorted happy
18775 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18776 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18777 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18778 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18779 salt
->salt_buf
[4] = salt
->salt_iter
;
18781 return (PARSER_OK
);
18784 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18786 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18788 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18790 u64
*digest
= (u64
*) hash_buf
->digest
;
18792 salt_t
*salt
= hash_buf
->salt
;
18794 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18802 char *iter_pos
= input_buf
+ 7;
18804 u32 iter
= atoi (iter_pos
);
18806 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18807 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18809 // first is *raw* salt
18811 char *salt_pos
= strchr (iter_pos
, ':');
18813 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18817 char *hash_pos
= strchr (salt_pos
, ':');
18819 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18821 u32 salt_len
= hash_pos
- salt_pos
;
18823 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18827 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18829 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18833 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18835 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18837 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18839 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18840 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18842 salt
->salt_len
= salt_len
;
18843 salt
->salt_iter
= iter
- 1;
18847 u8 tmp_buf
[100] = { 0 };
18849 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18851 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18853 memcpy (digest
, tmp_buf
, 64);
18855 digest
[0] = byte_swap_64 (digest
[0]);
18856 digest
[1] = byte_swap_64 (digest
[1]);
18857 digest
[2] = byte_swap_64 (digest
[2]);
18858 digest
[3] = byte_swap_64 (digest
[3]);
18859 digest
[4] = byte_swap_64 (digest
[4]);
18860 digest
[5] = byte_swap_64 (digest
[5]);
18861 digest
[6] = byte_swap_64 (digest
[6]);
18862 digest
[7] = byte_swap_64 (digest
[7]);
18864 // add some stuff to normal salt to make sorted happy
18866 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18867 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18868 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18869 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18870 salt
->salt_buf
[4] = salt
->salt_iter
;
18872 return (PARSER_OK
);
18875 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18877 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18879 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18881 uint
*digest
= (uint
*) hash_buf
->digest
;
18883 salt_t
*salt
= hash_buf
->salt
;
18889 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18891 char *hash_pos
= strchr (salt_pos
, '$');
18893 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18895 u32 salt_len
= hash_pos
- salt_pos
;
18897 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18901 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18903 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18907 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18908 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18926 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18927 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18929 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18930 salt
->salt_len
= 8;
18932 return (PARSER_OK
);
18935 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18937 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18939 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18941 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18943 if (c19
& 3) return (PARSER_HASH_VALUE
);
18945 salt_t
*salt
= hash_buf
->salt
;
18947 u32
*digest
= (u32
*) hash_buf
->digest
;
18951 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18952 | itoa64_to_int (input_buf
[2]) << 6
18953 | itoa64_to_int (input_buf
[3]) << 12
18954 | itoa64_to_int (input_buf
[4]) << 18;
18958 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18959 | itoa64_to_int (input_buf
[6]) << 6
18960 | itoa64_to_int (input_buf
[7]) << 12
18961 | itoa64_to_int (input_buf
[8]) << 18;
18963 salt
->salt_len
= 4;
18965 u8 tmp_buf
[100] = { 0 };
18967 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18969 memcpy (digest
, tmp_buf
, 8);
18973 IP (digest
[0], digest
[1], tt
);
18975 digest
[0] = rotr32 (digest
[0], 31);
18976 digest
[1] = rotr32 (digest
[1], 31);
18980 return (PARSER_OK
);
18983 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18985 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18987 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18989 u32
*digest
= (u32
*) hash_buf
->digest
;
18991 salt_t
*salt
= hash_buf
->salt
;
18997 char *type_pos
= input_buf
+ 6 + 1;
18999 char *salt_pos
= strchr (type_pos
, '*');
19001 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19003 u32 type_len
= salt_pos
- type_pos
;
19005 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19009 char *crypted_pos
= strchr (salt_pos
, '*');
19011 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19013 u32 salt_len
= crypted_pos
- salt_pos
;
19015 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19019 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19021 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19027 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19028 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19030 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19031 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19033 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19034 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19035 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19036 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19038 salt
->salt_len
= 24;
19039 salt
->salt_iter
= ROUNDS_RAR3
;
19041 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19042 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19044 digest
[0] = 0xc43d7b00;
19045 digest
[1] = 0x40070000;
19049 return (PARSER_OK
);
19052 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19054 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19056 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19058 u32
*digest
= (u32
*) hash_buf
->digest
;
19060 salt_t
*salt
= hash_buf
->salt
;
19062 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19068 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19070 char *param1_pos
= strchr (param0_pos
, '$');
19072 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19074 u32 param0_len
= param1_pos
- param0_pos
;
19078 char *param2_pos
= strchr (param1_pos
, '$');
19080 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19082 u32 param1_len
= param2_pos
- param1_pos
;
19086 char *param3_pos
= strchr (param2_pos
, '$');
19088 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19090 u32 param2_len
= param3_pos
- param2_pos
;
19094 char *param4_pos
= strchr (param3_pos
, '$');
19096 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19098 u32 param3_len
= param4_pos
- param3_pos
;
19102 char *param5_pos
= strchr (param4_pos
, '$');
19104 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19106 u32 param4_len
= param5_pos
- param4_pos
;
19110 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19112 char *salt_buf
= param1_pos
;
19113 char *iv
= param3_pos
;
19114 char *pswcheck
= param5_pos
;
19116 const uint salt_len
= atoi (param0_pos
);
19117 const uint iterations
= atoi (param2_pos
);
19118 const uint pswcheck_len
= atoi (param4_pos
);
19124 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19125 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19126 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19128 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19129 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19130 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19136 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19137 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19138 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19139 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19141 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19142 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19143 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19144 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19146 salt
->salt_len
= 16;
19148 salt
->salt_sign
[0] = iterations
;
19150 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19156 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19157 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19161 return (PARSER_OK
);
19164 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19166 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19168 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19170 u32
*digest
= (u32
*) hash_buf
->digest
;
19172 salt_t
*salt
= hash_buf
->salt
;
19174 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19181 char *account_pos
= input_buf
+ 11 + 1;
19187 if (account_pos
[0] == '*')
19191 data_pos
= strchr (account_pos
, '*');
19196 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19198 uint account_len
= data_pos
- account_pos
+ 1;
19200 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19205 data_len
= input_len
- 11 - 1 - account_len
- 2;
19207 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19211 /* assume $krb5tgs$23$checksum$edata2 */
19212 data_pos
= account_pos
;
19214 memcpy (krb5tgs
->account_info
, "**", 3);
19216 data_len
= input_len
- 11 - 1 - 1;
19219 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19221 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19223 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19225 const char p0
= data_pos
[i
+ 0];
19226 const char p1
= data_pos
[i
+ 1];
19228 *checksum_ptr
++ = hex_convert (p1
) << 0
19229 | hex_convert (p0
) << 4;
19232 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19234 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19237 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19239 const char p0
= data_pos
[i
+ 0];
19240 const char p1
= data_pos
[i
+ 1];
19241 *edata_ptr
++ = hex_convert (p1
) << 0
19242 | hex_convert (p0
) << 4;
19245 /* this is needed for hmac_md5 */
19246 *edata_ptr
++ = 0x80;
19248 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19249 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19250 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19251 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19253 salt
->salt_len
= 32;
19255 digest
[0] = krb5tgs
->checksum
[0];
19256 digest
[1] = krb5tgs
->checksum
[1];
19257 digest
[2] = krb5tgs
->checksum
[2];
19258 digest
[3] = krb5tgs
->checksum
[3];
19260 return (PARSER_OK
);
19263 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19265 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19267 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19269 u32
*digest
= (u32
*) hash_buf
->digest
;
19271 salt_t
*salt
= hash_buf
->salt
;
19278 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19282 char *wrapped_key_pos
;
19286 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19288 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19290 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19292 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19297 data_pos
= salt_pos
;
19299 wrapped_key_pos
= strchr (salt_pos
, '*');
19301 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19303 uint salt_len
= wrapped_key_pos
- salt_pos
;
19305 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19310 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19312 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19314 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19315 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19316 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19317 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19321 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19322 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19323 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19324 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19325 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19326 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19328 salt
->salt_len
= 40;
19330 digest
[0] = salt
->salt_buf
[0];
19331 digest
[1] = salt
->salt_buf
[1];
19332 digest
[2] = salt
->salt_buf
[2];
19333 digest
[3] = salt
->salt_buf
[3];
19335 return (PARSER_OK
);
19338 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19340 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19342 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19344 u32
*digest
= (u32
*) hash_buf
->digest
;
19346 salt_t
*salt
= hash_buf
->salt
;
19348 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19358 char *algorithm_pos
;
19360 char *final_random_seed_pos
;
19361 u32 final_random_seed_len
;
19363 char *transf_random_seed_pos
;
19364 u32 transf_random_seed_len
;
19369 /* default is no keyfile provided */
19370 char *keyfile_len_pos
;
19371 u32 keyfile_len
= 0;
19372 u32 is_keyfile_present
= 0;
19373 char *keyfile_inline_pos
;
19376 /* specific to version 1 */
19377 char *contents_len_pos
;
19379 char *contents_pos
;
19381 /* specific to version 2 */
19382 char *expected_bytes_pos
;
19383 u32 expected_bytes_len
;
19385 char *contents_hash_pos
;
19386 u32 contents_hash_len
;
19388 version_pos
= input_buf
+ 8 + 1 + 1;
19390 keepass
->version
= atoi (version_pos
);
19392 rounds_pos
= strchr (version_pos
, '*');
19394 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19398 salt
->salt_iter
= (atoi (rounds_pos
));
19400 algorithm_pos
= strchr (rounds_pos
, '*');
19402 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19406 keepass
->algorithm
= atoi (algorithm_pos
);
19408 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19410 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19412 final_random_seed_pos
++;
19414 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19415 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19416 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19417 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19419 if (keepass
->version
== 2)
19421 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19422 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19423 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19424 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19427 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19429 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19431 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19433 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19434 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19436 transf_random_seed_pos
++;
19438 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19439 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19440 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19441 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19442 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19443 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19444 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19445 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19447 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19449 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19451 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19453 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19457 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19458 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19459 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19460 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19462 if (keepass
->version
== 1)
19464 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19466 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19468 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19470 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19472 contents_hash_pos
++;
19474 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19475 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19476 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19477 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19478 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19479 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19480 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19481 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19483 /* get length of contents following */
19484 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19486 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19488 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19490 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19494 u32 inline_flag
= atoi (inline_flag_pos
);
19496 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19498 contents_len_pos
= strchr (inline_flag_pos
, '*');
19500 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19502 contents_len_pos
++;
19504 contents_len
= atoi (contents_len_pos
);
19506 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19508 contents_pos
= strchr (contents_len_pos
, '*');
19510 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19516 keepass
->contents_len
= contents_len
;
19518 contents_len
= contents_len
/ 4;
19520 keyfile_inline_pos
= strchr (contents_pos
, '*');
19522 u32 real_contents_len
;
19524 if (keyfile_inline_pos
== NULL
)
19525 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19528 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19529 keyfile_inline_pos
++;
19530 is_keyfile_present
= 1;
19533 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19535 for (i
= 0; i
< contents_len
; i
++)
19536 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19538 else if (keepass
->version
== 2)
19540 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19542 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19544 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19546 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19548 expected_bytes_pos
++;
19550 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19551 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19552 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19553 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19554 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19555 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19556 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19557 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19559 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19561 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19563 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19565 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19567 contents_hash_pos
++;
19569 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19570 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19571 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19572 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19573 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19574 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19575 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19576 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19578 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19580 if (keyfile_inline_pos
== NULL
)
19581 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19584 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19585 keyfile_inline_pos
++;
19586 is_keyfile_present
= 1;
19588 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19591 if (is_keyfile_present
!= 0)
19593 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19597 keyfile_len
= atoi (keyfile_len_pos
);
19599 keepass
->keyfile_len
= keyfile_len
;
19601 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19603 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19605 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19609 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19611 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19613 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19614 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19615 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19616 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19617 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19618 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19619 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19620 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19623 digest
[0] = keepass
->enc_iv
[0];
19624 digest
[1] = keepass
->enc_iv
[1];
19625 digest
[2] = keepass
->enc_iv
[2];
19626 digest
[3] = keepass
->enc_iv
[3];
19628 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19629 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19630 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19631 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19632 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19633 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19634 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19635 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19637 return (PARSER_OK
);
19640 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19642 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19644 u32
*digest
= (u32
*) hash_buf
->digest
;
19646 salt_t
*salt
= hash_buf
->salt
;
19648 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19649 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19650 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19651 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19652 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19653 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19654 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19655 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19657 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19659 uint salt_len
= input_len
- 64 - 1;
19661 char *salt_buf
= input_buf
+ 64 + 1;
19663 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19665 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19667 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19669 salt
->salt_len
= salt_len
;
19672 * we can precompute the first sha256 transform
19675 uint w
[16] = { 0 };
19677 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19678 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19679 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19680 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19681 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19682 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19683 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19684 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19685 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19686 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19687 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19688 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19689 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19690 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19691 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19692 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19694 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19696 sha256_64 (w
, pc256
);
19698 salt
->salt_buf_pc
[0] = pc256
[0];
19699 salt
->salt_buf_pc
[1] = pc256
[1];
19700 salt
->salt_buf_pc
[2] = pc256
[2];
19701 salt
->salt_buf_pc
[3] = pc256
[3];
19702 salt
->salt_buf_pc
[4] = pc256
[4];
19703 salt
->salt_buf_pc
[5] = pc256
[5];
19704 salt
->salt_buf_pc
[6] = pc256
[6];
19705 salt
->salt_buf_pc
[7] = pc256
[7];
19707 digest
[0] -= pc256
[0];
19708 digest
[1] -= pc256
[1];
19709 digest
[2] -= pc256
[2];
19710 digest
[3] -= pc256
[3];
19711 digest
[4] -= pc256
[4];
19712 digest
[5] -= pc256
[5];
19713 digest
[6] -= pc256
[6];
19714 digest
[7] -= pc256
[7];
19716 return (PARSER_OK
);
19719 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19721 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19723 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19725 u32
*digest
= (u32
*) hash_buf
->digest
;
19727 salt_t
*salt
= hash_buf
->salt
;
19733 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19735 char *data_buf_pos
= strchr (data_len_pos
, '$');
19737 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19739 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19741 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19742 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19746 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19748 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19750 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19752 u32 data_len
= atoi (data_len_pos
);
19754 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19760 char *salt_pos
= data_buf_pos
;
19762 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19763 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19764 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19765 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19767 // this is actually the CT, which is also the hash later (if matched)
19769 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19770 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19771 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19772 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19774 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19776 salt
->salt_iter
= 10 - 1;
19782 digest
[0] = salt
->salt_buf
[4];
19783 digest
[1] = salt
->salt_buf
[5];
19784 digest
[2] = salt
->salt_buf
[6];
19785 digest
[3] = salt
->salt_buf
[7];
19787 return (PARSER_OK
);
19790 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19792 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19794 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19796 u32
*digest
= (u32
*) hash_buf
->digest
;
19798 salt_t
*salt
= hash_buf
->salt
;
19804 char *salt_pos
= input_buf
+ 11 + 1;
19806 char *iter_pos
= strchr (salt_pos
, ',');
19808 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19810 u32 salt_len
= iter_pos
- salt_pos
;
19812 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19816 char *hash_pos
= strchr (iter_pos
, ',');
19818 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19820 u32 iter_len
= hash_pos
- iter_pos
;
19822 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19826 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19828 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19834 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19835 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19836 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19837 salt
->salt_buf
[3] = 0x00018000;
19839 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19840 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19841 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19842 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19844 salt
->salt_len
= salt_len
/ 2;
19846 salt
->salt_iter
= atoi (iter_pos
) - 1;
19852 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19853 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19854 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19855 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19856 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19857 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19858 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19859 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19861 return (PARSER_OK
);
19864 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19866 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19868 u32
*digest
= (u32
*) hash_buf
->digest
;
19870 salt_t
*salt
= hash_buf
->salt
;
19876 char *hash_pos
= input_buf
+ 64;
19877 char *salt1_pos
= input_buf
+ 128;
19878 char *salt2_pos
= input_buf
;
19884 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19885 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19886 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19887 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19889 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19890 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19891 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19892 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19894 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19895 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19896 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19897 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19899 salt
->salt_len
= 48;
19901 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19907 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19908 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19909 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19910 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19911 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19912 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19913 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19914 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19916 return (PARSER_OK
);
19919 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19921 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
19923 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19924 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19926 u32
*digest
= (u32
*) hash_buf
->digest
;
19928 salt_t
*salt
= hash_buf
->salt
;
19930 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
19936 char *param0_pos
= input_buf
+ 6 + 1;
19938 char *param1_pos
= strchr (param0_pos
, '*');
19940 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19942 u32 param0_len
= param1_pos
- param0_pos
;
19946 char *param2_pos
= strchr (param1_pos
, '*');
19948 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19950 u32 param1_len
= param2_pos
- param1_pos
;
19954 char *param3_pos
= strchr (param2_pos
, '*');
19956 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19958 u32 param2_len
= param3_pos
- param2_pos
;
19962 char *param4_pos
= strchr (param3_pos
, '*');
19964 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19966 u32 param3_len
= param4_pos
- param3_pos
;
19970 char *param5_pos
= strchr (param4_pos
, '*');
19972 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19974 u32 param4_len
= param5_pos
- param4_pos
;
19978 char *param6_pos
= strchr (param5_pos
, '*');
19980 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19982 u32 param5_len
= param6_pos
- param5_pos
;
19986 char *param7_pos
= strchr (param6_pos
, '*');
19988 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19990 u32 param6_len
= param7_pos
- param6_pos
;
19994 char *param8_pos
= strchr (param7_pos
, '*');
19996 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19998 u32 param7_len
= param8_pos
- param7_pos
;
20002 const uint type
= atoi (param0_pos
);
20003 const uint mode
= atoi (param1_pos
);
20004 const uint magic
= atoi (param2_pos
);
20006 char *salt_buf
= param3_pos
;
20008 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20010 const uint compress_length
= atoi (param5_pos
);
20012 char *data_buf
= param6_pos
;
20013 char *auth
= param7_pos
;
20019 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20021 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20023 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20025 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20027 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20029 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20031 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20033 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20035 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20037 if (type
!= 0) return (PARSER_SALT_VALUE
);
20039 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20041 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20043 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20051 zip2
->magic
= magic
;
20055 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20056 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20057 zip2
->salt_buf
[2] = 0;
20058 zip2
->salt_buf
[3] = 0;
20060 zip2
->salt_len
= 8;
20062 else if (mode
== 2)
20064 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20065 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20066 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20067 zip2
->salt_buf
[3] = 0;
20069 zip2
->salt_len
= 12;
20071 else if (mode
== 3)
20073 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20074 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20075 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20076 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20078 zip2
->salt_len
= 16;
20081 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20082 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20083 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20084 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20086 zip2
->verify_bytes
= verify_bytes
;
20088 zip2
->compress_length
= compress_length
;
20090 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20092 for (uint i
= 0; i
< param6_len
; i
+= 2)
20094 const char p0
= data_buf
[i
+ 0];
20095 const char p1
= data_buf
[i
+ 1];
20097 *data_buf_ptr
++ = hex_convert (p1
) << 0
20098 | hex_convert (p0
) << 4;
20103 *data_buf_ptr
= 0x80;
20105 char *auth_ptr
= (char *) zip2
->auth_buf
;
20107 for (uint i
= 0; i
< param7_len
; i
+= 2)
20109 const char p0
= auth
[i
+ 0];
20110 const char p1
= auth
[i
+ 1];
20112 *auth_ptr
++ = hex_convert (p1
) << 0
20113 | hex_convert (p0
) << 4;
20122 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20123 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20124 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20125 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20126 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20127 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20128 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20129 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20131 salt
->salt_len
= 32;
20133 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20136 * digest buf (fake)
20139 digest
[0] = zip2
->auth_buf
[0];
20140 digest
[1] = zip2
->auth_buf
[1];
20141 digest
[2] = zip2
->auth_buf
[2];
20142 digest
[3] = zip2
->auth_buf
[3];
20144 return (PARSER_OK
);
20148 * parallel running threads
20153 BOOL WINAPI
sigHandler_default (DWORD sig
)
20157 case CTRL_CLOSE_EVENT
:
20160 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20161 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20162 * function otherwise it is too late (e.g. after returning from this function)
20167 SetConsoleCtrlHandler (NULL
, TRUE
);
20174 case CTRL_LOGOFF_EVENT
:
20175 case CTRL_SHUTDOWN_EVENT
:
20179 SetConsoleCtrlHandler (NULL
, TRUE
);
20187 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20191 case CTRL_CLOSE_EVENT
:
20195 SetConsoleCtrlHandler (NULL
, TRUE
);
20202 case CTRL_LOGOFF_EVENT
:
20203 case CTRL_SHUTDOWN_EVENT
:
20207 SetConsoleCtrlHandler (NULL
, TRUE
);
20215 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20217 if (callback
== NULL
)
20219 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20223 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20229 void sigHandler_default (int sig
)
20233 signal (sig
, NULL
);
20236 void sigHandler_benchmark (int sig
)
20240 signal (sig
, NULL
);
20243 void hc_signal (void (callback
) (int))
20245 if (callback
== NULL
) callback
= SIG_DFL
;
20247 signal (SIGINT
, callback
);
20248 signal (SIGTERM
, callback
);
20249 signal (SIGABRT
, callback
);
20254 void status_display ();
20256 void *thread_keypress (void *p
)
20258 int benchmark
= *((int *) p
);
20260 uint quiet
= data
.quiet
;
20264 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20266 int ch
= tty_getchar();
20268 if (ch
== -1) break;
20270 if (ch
== 0) continue;
20272 //https://github.com/hashcat/hashcat/issues/302
20277 hc_thread_mutex_lock (mux_display
);
20293 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20294 if (quiet
== 0) fflush (stdout
);
20306 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20307 if (quiet
== 0) fflush (stdout
);
20319 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20320 if (quiet
== 0) fflush (stdout
);
20332 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20333 if (quiet
== 0) fflush (stdout
);
20341 if (benchmark
== 1) break;
20343 stop_at_checkpoint ();
20347 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20348 if (quiet
== 0) fflush (stdout
);
20356 if (benchmark
== 1)
20368 //https://github.com/hashcat/hashcat/issues/302
20373 hc_thread_mutex_unlock (mux_display
);
20385 bool class_num (const u8 c
)
20387 return ((c
>= '0') && (c
<= '9'));
20390 bool class_lower (const u8 c
)
20392 return ((c
>= 'a') && (c
<= 'z'));
20395 bool class_upper (const u8 c
)
20397 return ((c
>= 'A') && (c
<= 'Z'));
20400 bool class_alpha (const u8 c
)
20402 return (class_lower (c
) || class_upper (c
));
20405 int conv_ctoi (const u8 c
)
20411 else if (class_upper (c
))
20413 return c
- 'A' + 10;
20419 int conv_itoc (const u8 c
)
20427 return c
+ 'A' - 10;
20437 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20438 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20439 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20440 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20441 #define MAX_KERNEL_RULES 255
20442 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20443 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20444 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20446 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20447 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20448 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20449 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20451 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20456 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20458 switch (rule_buf
[rule_pos
])
20464 case RULE_OP_MANGLE_NOOP
:
20465 SET_NAME (rule
, rule_buf
[rule_pos
]);
20468 case RULE_OP_MANGLE_LREST
:
20469 SET_NAME (rule
, rule_buf
[rule_pos
]);
20472 case RULE_OP_MANGLE_UREST
:
20473 SET_NAME (rule
, rule_buf
[rule_pos
]);
20476 case RULE_OP_MANGLE_LREST_UFIRST
:
20477 SET_NAME (rule
, rule_buf
[rule_pos
]);
20480 case RULE_OP_MANGLE_UREST_LFIRST
:
20481 SET_NAME (rule
, rule_buf
[rule_pos
]);
20484 case RULE_OP_MANGLE_TREST
:
20485 SET_NAME (rule
, rule_buf
[rule_pos
]);
20488 case RULE_OP_MANGLE_TOGGLE_AT
:
20489 SET_NAME (rule
, rule_buf
[rule_pos
]);
20490 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20493 case RULE_OP_MANGLE_REVERSE
:
20494 SET_NAME (rule
, rule_buf
[rule_pos
]);
20497 case RULE_OP_MANGLE_DUPEWORD
:
20498 SET_NAME (rule
, rule_buf
[rule_pos
]);
20501 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20502 SET_NAME (rule
, rule_buf
[rule_pos
]);
20503 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20506 case RULE_OP_MANGLE_REFLECT
:
20507 SET_NAME (rule
, rule_buf
[rule_pos
]);
20510 case RULE_OP_MANGLE_ROTATE_LEFT
:
20511 SET_NAME (rule
, rule_buf
[rule_pos
]);
20514 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20515 SET_NAME (rule
, rule_buf
[rule_pos
]);
20518 case RULE_OP_MANGLE_APPEND
:
20519 SET_NAME (rule
, rule_buf
[rule_pos
]);
20520 SET_P0 (rule
, rule_buf
[rule_pos
]);
20523 case RULE_OP_MANGLE_PREPEND
:
20524 SET_NAME (rule
, rule_buf
[rule_pos
]);
20525 SET_P0 (rule
, rule_buf
[rule_pos
]);
20528 case RULE_OP_MANGLE_DELETE_FIRST
:
20529 SET_NAME (rule
, rule_buf
[rule_pos
]);
20532 case RULE_OP_MANGLE_DELETE_LAST
:
20533 SET_NAME (rule
, rule_buf
[rule_pos
]);
20536 case RULE_OP_MANGLE_DELETE_AT
:
20537 SET_NAME (rule
, rule_buf
[rule_pos
]);
20538 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20541 case RULE_OP_MANGLE_EXTRACT
:
20542 SET_NAME (rule
, rule_buf
[rule_pos
]);
20543 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20544 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20547 case RULE_OP_MANGLE_OMIT
:
20548 SET_NAME (rule
, rule_buf
[rule_pos
]);
20549 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20550 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20553 case RULE_OP_MANGLE_INSERT
:
20554 SET_NAME (rule
, rule_buf
[rule_pos
]);
20555 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20556 SET_P1 (rule
, rule_buf
[rule_pos
]);
20559 case RULE_OP_MANGLE_OVERSTRIKE
:
20560 SET_NAME (rule
, rule_buf
[rule_pos
]);
20561 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20562 SET_P1 (rule
, rule_buf
[rule_pos
]);
20565 case RULE_OP_MANGLE_TRUNCATE_AT
:
20566 SET_NAME (rule
, rule_buf
[rule_pos
]);
20567 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20570 case RULE_OP_MANGLE_REPLACE
:
20571 SET_NAME (rule
, rule_buf
[rule_pos
]);
20572 SET_P0 (rule
, rule_buf
[rule_pos
]);
20573 SET_P1 (rule
, rule_buf
[rule_pos
]);
20576 case RULE_OP_MANGLE_PURGECHAR
:
20580 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20584 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20585 SET_NAME (rule
, rule_buf
[rule_pos
]);
20586 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20589 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20590 SET_NAME (rule
, rule_buf
[rule_pos
]);
20591 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20594 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20595 SET_NAME (rule
, rule_buf
[rule_pos
]);
20598 case RULE_OP_MANGLE_SWITCH_FIRST
:
20599 SET_NAME (rule
, rule_buf
[rule_pos
]);
20602 case RULE_OP_MANGLE_SWITCH_LAST
:
20603 SET_NAME (rule
, rule_buf
[rule_pos
]);
20606 case RULE_OP_MANGLE_SWITCH_AT
:
20607 SET_NAME (rule
, rule_buf
[rule_pos
]);
20608 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20609 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20612 case RULE_OP_MANGLE_CHR_SHIFTL
:
20613 SET_NAME (rule
, rule_buf
[rule_pos
]);
20614 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20617 case RULE_OP_MANGLE_CHR_SHIFTR
:
20618 SET_NAME (rule
, rule_buf
[rule_pos
]);
20619 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20622 case RULE_OP_MANGLE_CHR_INCR
:
20623 SET_NAME (rule
, rule_buf
[rule_pos
]);
20624 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20627 case RULE_OP_MANGLE_CHR_DECR
:
20628 SET_NAME (rule
, rule_buf
[rule_pos
]);
20629 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20632 case RULE_OP_MANGLE_REPLACE_NP1
:
20633 SET_NAME (rule
, rule_buf
[rule_pos
]);
20634 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20637 case RULE_OP_MANGLE_REPLACE_NM1
:
20638 SET_NAME (rule
, rule_buf
[rule_pos
]);
20639 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20642 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20643 SET_NAME (rule
, rule_buf
[rule_pos
]);
20644 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20647 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20648 SET_NAME (rule
, rule_buf
[rule_pos
]);
20649 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20652 case RULE_OP_MANGLE_TITLE
:
20653 SET_NAME (rule
, rule_buf
[rule_pos
]);
20662 if (rule_pos
< rule_len
) return (-1);
20667 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20671 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20675 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20679 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20683 case RULE_OP_MANGLE_NOOP
:
20684 rule_buf
[rule_pos
] = rule_cmd
;
20687 case RULE_OP_MANGLE_LREST
:
20688 rule_buf
[rule_pos
] = rule_cmd
;
20691 case RULE_OP_MANGLE_UREST
:
20692 rule_buf
[rule_pos
] = rule_cmd
;
20695 case RULE_OP_MANGLE_LREST_UFIRST
:
20696 rule_buf
[rule_pos
] = rule_cmd
;
20699 case RULE_OP_MANGLE_UREST_LFIRST
:
20700 rule_buf
[rule_pos
] = rule_cmd
;
20703 case RULE_OP_MANGLE_TREST
:
20704 rule_buf
[rule_pos
] = rule_cmd
;
20707 case RULE_OP_MANGLE_TOGGLE_AT
:
20708 rule_buf
[rule_pos
] = rule_cmd
;
20709 GET_P0_CONV (rule
);
20712 case RULE_OP_MANGLE_REVERSE
:
20713 rule_buf
[rule_pos
] = rule_cmd
;
20716 case RULE_OP_MANGLE_DUPEWORD
:
20717 rule_buf
[rule_pos
] = rule_cmd
;
20720 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20721 rule_buf
[rule_pos
] = rule_cmd
;
20722 GET_P0_CONV (rule
);
20725 case RULE_OP_MANGLE_REFLECT
:
20726 rule_buf
[rule_pos
] = rule_cmd
;
20729 case RULE_OP_MANGLE_ROTATE_LEFT
:
20730 rule_buf
[rule_pos
] = rule_cmd
;
20733 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20734 rule_buf
[rule_pos
] = rule_cmd
;
20737 case RULE_OP_MANGLE_APPEND
:
20738 rule_buf
[rule_pos
] = rule_cmd
;
20742 case RULE_OP_MANGLE_PREPEND
:
20743 rule_buf
[rule_pos
] = rule_cmd
;
20747 case RULE_OP_MANGLE_DELETE_FIRST
:
20748 rule_buf
[rule_pos
] = rule_cmd
;
20751 case RULE_OP_MANGLE_DELETE_LAST
:
20752 rule_buf
[rule_pos
] = rule_cmd
;
20755 case RULE_OP_MANGLE_DELETE_AT
:
20756 rule_buf
[rule_pos
] = rule_cmd
;
20757 GET_P0_CONV (rule
);
20760 case RULE_OP_MANGLE_EXTRACT
:
20761 rule_buf
[rule_pos
] = rule_cmd
;
20762 GET_P0_CONV (rule
);
20763 GET_P1_CONV (rule
);
20766 case RULE_OP_MANGLE_OMIT
:
20767 rule_buf
[rule_pos
] = rule_cmd
;
20768 GET_P0_CONV (rule
);
20769 GET_P1_CONV (rule
);
20772 case RULE_OP_MANGLE_INSERT
:
20773 rule_buf
[rule_pos
] = rule_cmd
;
20774 GET_P0_CONV (rule
);
20778 case RULE_OP_MANGLE_OVERSTRIKE
:
20779 rule_buf
[rule_pos
] = rule_cmd
;
20780 GET_P0_CONV (rule
);
20784 case RULE_OP_MANGLE_TRUNCATE_AT
:
20785 rule_buf
[rule_pos
] = rule_cmd
;
20786 GET_P0_CONV (rule
);
20789 case RULE_OP_MANGLE_REPLACE
:
20790 rule_buf
[rule_pos
] = rule_cmd
;
20795 case RULE_OP_MANGLE_PURGECHAR
:
20799 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20803 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20804 rule_buf
[rule_pos
] = rule_cmd
;
20805 GET_P0_CONV (rule
);
20808 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20809 rule_buf
[rule_pos
] = rule_cmd
;
20810 GET_P0_CONV (rule
);
20813 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20814 rule_buf
[rule_pos
] = rule_cmd
;
20817 case RULE_OP_MANGLE_SWITCH_FIRST
:
20818 rule_buf
[rule_pos
] = rule_cmd
;
20821 case RULE_OP_MANGLE_SWITCH_LAST
:
20822 rule_buf
[rule_pos
] = rule_cmd
;
20825 case RULE_OP_MANGLE_SWITCH_AT
:
20826 rule_buf
[rule_pos
] = rule_cmd
;
20827 GET_P0_CONV (rule
);
20828 GET_P1_CONV (rule
);
20831 case RULE_OP_MANGLE_CHR_SHIFTL
:
20832 rule_buf
[rule_pos
] = rule_cmd
;
20833 GET_P0_CONV (rule
);
20836 case RULE_OP_MANGLE_CHR_SHIFTR
:
20837 rule_buf
[rule_pos
] = rule_cmd
;
20838 GET_P0_CONV (rule
);
20841 case RULE_OP_MANGLE_CHR_INCR
:
20842 rule_buf
[rule_pos
] = rule_cmd
;
20843 GET_P0_CONV (rule
);
20846 case RULE_OP_MANGLE_CHR_DECR
:
20847 rule_buf
[rule_pos
] = rule_cmd
;
20848 GET_P0_CONV (rule
);
20851 case RULE_OP_MANGLE_REPLACE_NP1
:
20852 rule_buf
[rule_pos
] = rule_cmd
;
20853 GET_P0_CONV (rule
);
20856 case RULE_OP_MANGLE_REPLACE_NM1
:
20857 rule_buf
[rule_pos
] = rule_cmd
;
20858 GET_P0_CONV (rule
);
20861 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20862 rule_buf
[rule_pos
] = rule_cmd
;
20863 GET_P0_CONV (rule
);
20866 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20867 rule_buf
[rule_pos
] = rule_cmd
;
20868 GET_P0_CONV (rule
);
20871 case RULE_OP_MANGLE_TITLE
:
20872 rule_buf
[rule_pos
] = rule_cmd
;
20876 return rule_pos
- 1;
20894 * CPU rules : this is from hashcat sources, cpu based rules
20897 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20898 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20900 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20901 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20902 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20904 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20905 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20906 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20908 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20912 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20917 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20921 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20926 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20930 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20935 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20940 for (l
= 0; l
< arr_len
; l
++)
20942 r
= arr_len
- 1 - l
;
20946 MANGLE_SWITCH (arr
, l
, r
);
20952 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20954 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20956 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20958 return (arr_len
* 2);
20961 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20963 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20965 int orig_len
= arr_len
;
20969 for (i
= 0; i
< times
; i
++)
20971 memcpy (&arr
[arr_len
], arr
, orig_len
);
20973 arr_len
+= orig_len
;
20979 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20981 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20983 mangle_double (arr
, arr_len
);
20985 mangle_reverse (arr
+ arr_len
, arr_len
);
20987 return (arr_len
* 2);
20990 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20995 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20997 MANGLE_SWITCH (arr
, l
, r
);
21003 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21008 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21010 MANGLE_SWITCH (arr
, l
, r
);
21016 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21018 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21022 return (arr_len
+ 1);
21025 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21027 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21031 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21033 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21038 return (arr_len
+ 1);
21041 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21043 if (upos
>= arr_len
) return (arr_len
);
21047 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21049 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21052 return (arr_len
- 1);
21055 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21057 if (upos
>= arr_len
) return (arr_len
);
21059 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21063 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21065 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21071 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21073 if (upos
>= arr_len
) return (arr_len
);
21075 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21079 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21081 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21084 return (arr_len
- ulen
);
21087 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21089 if (upos
>= arr_len
) return (arr_len
);
21091 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21095 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21097 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21102 return (arr_len
+ 1);
21105 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
)
21107 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21109 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21111 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21113 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21115 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21117 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21119 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21121 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21123 return (arr_len
+ arr2_cpy
);
21126 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21128 if (upos
>= arr_len
) return (arr_len
);
21135 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21137 if (upos
>= arr_len
) return (arr_len
);
21139 memset (arr
+ upos
, 0, arr_len
- upos
);
21144 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21148 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21150 if (arr
[arr_pos
] != oldc
) continue;
21152 arr
[arr_pos
] = newc
;
21158 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21164 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21166 if (arr
[arr_pos
] == c
) continue;
21168 arr
[ret_len
] = arr
[arr_pos
];
21176 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21178 if (ulen
> arr_len
) return (arr_len
);
21180 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21182 char cs
[100] = { 0 };
21184 memcpy (cs
, arr
, ulen
);
21188 for (i
= 0; i
< ulen
; i
++)
21192 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21198 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21200 if (ulen
> arr_len
) return (arr_len
);
21202 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21204 int upos
= arr_len
- ulen
;
21208 for (i
= 0; i
< ulen
; i
++)
21210 char c
= arr
[upos
+ i
];
21212 arr_len
= mangle_append (arr
, arr_len
, c
);
21218 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21220 if ( arr_len
== 0) return (arr_len
);
21221 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21223 char c
= arr
[upos
];
21227 for (i
= 0; i
< ulen
; i
++)
21229 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21235 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21237 if ( arr_len
== 0) return (arr_len
);
21238 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21242 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21244 int new_pos
= arr_pos
* 2;
21246 arr
[new_pos
] = arr
[arr_pos
];
21248 arr
[new_pos
+ 1] = arr
[arr_pos
];
21251 return (arr_len
* 2);
21254 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21256 if (upos
>= arr_len
) return (arr_len
);
21257 if (upos2
>= arr_len
) return (arr_len
);
21259 MANGLE_SWITCH (arr
, upos
, upos2
);
21264 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21266 MANGLE_SWITCH (arr
, upos
, upos2
);
21271 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21273 if (upos
>= arr_len
) return (arr_len
);
21280 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21282 if (upos
>= arr_len
) return (arr_len
);
21289 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21291 if (upos
>= arr_len
) return (arr_len
);
21298 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21300 if (upos
>= arr_len
) return (arr_len
);
21307 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21309 int upper_next
= 1;
21313 for (pos
= 0; pos
< arr_len
; pos
++)
21315 if (arr
[pos
] == ' ')
21326 MANGLE_UPPER_AT (arr
, pos
);
21330 MANGLE_LOWER_AT (arr
, pos
);
21337 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21339 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21345 for (j
= 0; j
< rp_gen_num
; j
++)
21352 switch ((char) get_random_num (0, 9))
21355 r
= get_random_num (0, sizeof (grp_op_nop
));
21356 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21360 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21361 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21362 p1
= get_random_num (0, sizeof (grp_pos
));
21363 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21367 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21368 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21369 p1
= get_random_num (1, 6);
21370 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21374 r
= get_random_num (0, sizeof (grp_op_chr
));
21375 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21376 p1
= get_random_num (0x20, 0x7e);
21377 rule_buf
[rule_pos
++] = (char) p1
;
21381 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21382 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21383 p1
= get_random_num (0x20, 0x7e);
21384 rule_buf
[rule_pos
++] = (char) p1
;
21385 p2
= get_random_num (0x20, 0x7e);
21387 p2
= get_random_num (0x20, 0x7e);
21388 rule_buf
[rule_pos
++] = (char) p2
;
21392 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21393 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21394 p1
= get_random_num (0, sizeof (grp_pos
));
21395 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21396 p2
= get_random_num (0x20, 0x7e);
21397 rule_buf
[rule_pos
++] = (char) p2
;
21401 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21402 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21403 p1
= get_random_num (0, sizeof (grp_pos
));
21404 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21405 p2
= get_random_num (0, sizeof (grp_pos
));
21407 p2
= get_random_num (0, sizeof (grp_pos
));
21408 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21412 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21413 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21414 p1
= get_random_num (0, sizeof (grp_pos
));
21415 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21416 p2
= get_random_num (1, sizeof (grp_pos
));
21418 p2
= get_random_num (1, sizeof (grp_pos
));
21419 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21423 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21424 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21425 p1
= get_random_num (0, sizeof (grp_pos
));
21426 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21427 p2
= get_random_num (1, sizeof (grp_pos
));
21428 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21429 p3
= get_random_num (0, sizeof (grp_pos
));
21430 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21438 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21440 char mem
[BLOCK_SIZE
] = { 0 };
21442 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21444 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21446 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21448 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21450 int out_len
= in_len
;
21451 int mem_len
= in_len
;
21453 memcpy (out
, in
, out_len
);
21457 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21462 switch (rule
[rule_pos
])
21467 case RULE_OP_MANGLE_NOOP
:
21470 case RULE_OP_MANGLE_LREST
:
21471 out_len
= mangle_lrest (out
, out_len
);
21474 case RULE_OP_MANGLE_UREST
:
21475 out_len
= mangle_urest (out
, out_len
);
21478 case RULE_OP_MANGLE_LREST_UFIRST
:
21479 out_len
= mangle_lrest (out
, out_len
);
21480 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21483 case RULE_OP_MANGLE_UREST_LFIRST
:
21484 out_len
= mangle_urest (out
, out_len
);
21485 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21488 case RULE_OP_MANGLE_TREST
:
21489 out_len
= mangle_trest (out
, out_len
);
21492 case RULE_OP_MANGLE_TOGGLE_AT
:
21493 NEXT_RULEPOS (rule_pos
);
21494 NEXT_RPTOI (rule
, rule_pos
, upos
);
21495 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21498 case RULE_OP_MANGLE_REVERSE
:
21499 out_len
= mangle_reverse (out
, out_len
);
21502 case RULE_OP_MANGLE_DUPEWORD
:
21503 out_len
= mangle_double (out
, out_len
);
21506 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21507 NEXT_RULEPOS (rule_pos
);
21508 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21509 out_len
= mangle_double_times (out
, out_len
, ulen
);
21512 case RULE_OP_MANGLE_REFLECT
:
21513 out_len
= mangle_reflect (out
, out_len
);
21516 case RULE_OP_MANGLE_ROTATE_LEFT
:
21517 mangle_rotate_left (out
, out_len
);
21520 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21521 mangle_rotate_right (out
, out_len
);
21524 case RULE_OP_MANGLE_APPEND
:
21525 NEXT_RULEPOS (rule_pos
);
21526 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21529 case RULE_OP_MANGLE_PREPEND
:
21530 NEXT_RULEPOS (rule_pos
);
21531 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21534 case RULE_OP_MANGLE_DELETE_FIRST
:
21535 out_len
= mangle_delete_at (out
, out_len
, 0);
21538 case RULE_OP_MANGLE_DELETE_LAST
:
21539 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21542 case RULE_OP_MANGLE_DELETE_AT
:
21543 NEXT_RULEPOS (rule_pos
);
21544 NEXT_RPTOI (rule
, rule_pos
, upos
);
21545 out_len
= mangle_delete_at (out
, out_len
, upos
);
21548 case RULE_OP_MANGLE_EXTRACT
:
21549 NEXT_RULEPOS (rule_pos
);
21550 NEXT_RPTOI (rule
, rule_pos
, upos
);
21551 NEXT_RULEPOS (rule_pos
);
21552 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21553 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21556 case RULE_OP_MANGLE_OMIT
:
21557 NEXT_RULEPOS (rule_pos
);
21558 NEXT_RPTOI (rule
, rule_pos
, upos
);
21559 NEXT_RULEPOS (rule_pos
);
21560 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21561 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21564 case RULE_OP_MANGLE_INSERT
:
21565 NEXT_RULEPOS (rule_pos
);
21566 NEXT_RPTOI (rule
, rule_pos
, upos
);
21567 NEXT_RULEPOS (rule_pos
);
21568 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21571 case RULE_OP_MANGLE_OVERSTRIKE
:
21572 NEXT_RULEPOS (rule_pos
);
21573 NEXT_RPTOI (rule
, rule_pos
, upos
);
21574 NEXT_RULEPOS (rule_pos
);
21575 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21578 case RULE_OP_MANGLE_TRUNCATE_AT
:
21579 NEXT_RULEPOS (rule_pos
);
21580 NEXT_RPTOI (rule
, rule_pos
, upos
);
21581 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21584 case RULE_OP_MANGLE_REPLACE
:
21585 NEXT_RULEPOS (rule_pos
);
21586 NEXT_RULEPOS (rule_pos
);
21587 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21590 case RULE_OP_MANGLE_PURGECHAR
:
21591 NEXT_RULEPOS (rule_pos
);
21592 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21595 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21599 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21600 NEXT_RULEPOS (rule_pos
);
21601 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21602 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21605 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21606 NEXT_RULEPOS (rule_pos
);
21607 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21608 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21611 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21612 out_len
= mangle_dupechar (out
, out_len
);
21615 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21616 NEXT_RULEPOS (rule_pos
);
21617 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21618 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21621 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21622 NEXT_RULEPOS (rule_pos
);
21623 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21624 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21627 case RULE_OP_MANGLE_SWITCH_FIRST
:
21628 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21631 case RULE_OP_MANGLE_SWITCH_LAST
:
21632 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21635 case RULE_OP_MANGLE_SWITCH_AT
:
21636 NEXT_RULEPOS (rule_pos
);
21637 NEXT_RPTOI (rule
, rule_pos
, upos
);
21638 NEXT_RULEPOS (rule_pos
);
21639 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21640 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21643 case RULE_OP_MANGLE_CHR_SHIFTL
:
21644 NEXT_RULEPOS (rule_pos
);
21645 NEXT_RPTOI (rule
, rule_pos
, upos
);
21646 mangle_chr_shiftl (out
, out_len
, upos
);
21649 case RULE_OP_MANGLE_CHR_SHIFTR
:
21650 NEXT_RULEPOS (rule_pos
);
21651 NEXT_RPTOI (rule
, rule_pos
, upos
);
21652 mangle_chr_shiftr (out
, out_len
, upos
);
21655 case RULE_OP_MANGLE_CHR_INCR
:
21656 NEXT_RULEPOS (rule_pos
);
21657 NEXT_RPTOI (rule
, rule_pos
, upos
);
21658 mangle_chr_incr (out
, out_len
, upos
);
21661 case RULE_OP_MANGLE_CHR_DECR
:
21662 NEXT_RULEPOS (rule_pos
);
21663 NEXT_RPTOI (rule
, rule_pos
, upos
);
21664 mangle_chr_decr (out
, out_len
, upos
);
21667 case RULE_OP_MANGLE_REPLACE_NP1
:
21668 NEXT_RULEPOS (rule_pos
);
21669 NEXT_RPTOI (rule
, rule_pos
, upos
);
21670 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21673 case RULE_OP_MANGLE_REPLACE_NM1
:
21674 NEXT_RULEPOS (rule_pos
);
21675 NEXT_RPTOI (rule
, rule_pos
, upos
);
21676 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21679 case RULE_OP_MANGLE_TITLE
:
21680 out_len
= mangle_title (out
, out_len
);
21683 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21684 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21685 NEXT_RULEPOS (rule_pos
);
21686 NEXT_RPTOI (rule
, rule_pos
, upos
);
21687 NEXT_RULEPOS (rule_pos
);
21688 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21689 NEXT_RULEPOS (rule_pos
);
21690 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21691 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21694 case RULE_OP_MANGLE_APPEND_MEMORY
:
21695 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21696 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21697 memcpy (out
+ out_len
, mem
, mem_len
);
21698 out_len
+= mem_len
;
21701 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21702 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21703 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21704 memcpy (mem
+ mem_len
, out
, out_len
);
21705 out_len
+= mem_len
;
21706 memcpy (out
, mem
, out_len
);
21709 case RULE_OP_MEMORIZE_WORD
:
21710 memcpy (mem
, out
, out_len
);
21714 case RULE_OP_REJECT_LESS
:
21715 NEXT_RULEPOS (rule_pos
);
21716 NEXT_RPTOI (rule
, rule_pos
, upos
);
21717 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21720 case RULE_OP_REJECT_GREATER
:
21721 NEXT_RULEPOS (rule_pos
);
21722 NEXT_RPTOI (rule
, rule_pos
, upos
);
21723 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21726 case RULE_OP_REJECT_CONTAIN
:
21727 NEXT_RULEPOS (rule_pos
);
21728 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21731 case RULE_OP_REJECT_NOT_CONTAIN
:
21732 NEXT_RULEPOS (rule_pos
);
21733 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21736 case RULE_OP_REJECT_EQUAL_FIRST
:
21737 NEXT_RULEPOS (rule_pos
);
21738 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21741 case RULE_OP_REJECT_EQUAL_LAST
:
21742 NEXT_RULEPOS (rule_pos
);
21743 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21746 case RULE_OP_REJECT_EQUAL_AT
:
21747 NEXT_RULEPOS (rule_pos
);
21748 NEXT_RPTOI (rule
, rule_pos
, upos
);
21749 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21750 NEXT_RULEPOS (rule_pos
);
21751 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21754 case RULE_OP_REJECT_CONTAINS
:
21755 NEXT_RULEPOS (rule_pos
);
21756 NEXT_RPTOI (rule
, rule_pos
, upos
);
21757 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21758 NEXT_RULEPOS (rule_pos
);
21759 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21760 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21763 case RULE_OP_REJECT_MEMORY
:
21764 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21768 return (RULE_RC_SYNTAX_ERROR
);
21773 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);