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
= 1000 - 1;
12793 digest
[0] = tc
->data_buf
[0];
12795 return (PARSER_OK
);
12798 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12800 u32
*digest
= (u32
*) hash_buf
->digest
;
12802 salt_t
*salt
= hash_buf
->salt
;
12804 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12806 if (input_len
== 0)
12808 log_error ("TrueCrypt container not specified");
12813 FILE *fp
= fopen (input_buf
, "rb");
12817 log_error ("%s: %s", input_buf
, strerror (errno
));
12822 char buf
[512] = { 0 };
12824 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12828 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12830 memcpy (tc
->salt_buf
, buf
, 64);
12832 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12834 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12836 salt
->salt_len
= 4;
12838 salt
->salt_iter
= 2000 - 1;
12840 digest
[0] = tc
->data_buf
[0];
12842 return (PARSER_OK
);
12845 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12847 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12849 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12851 u32
*digest
= (u32
*) hash_buf
->digest
;
12853 salt_t
*salt
= hash_buf
->salt
;
12855 char *salt_pos
= input_buf
+ 6;
12857 char *hash_pos
= strchr (salt_pos
, '$');
12859 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12861 uint salt_len
= hash_pos
- salt_pos
;
12863 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12865 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12867 salt
->salt_len
= salt_len
;
12869 salt
->salt_iter
= 1000;
12873 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12875 return (PARSER_OK
);
12878 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12880 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12882 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12884 u32
*digest
= (u32
*) hash_buf
->digest
;
12886 salt_t
*salt
= hash_buf
->salt
;
12888 char *iter_pos
= input_buf
+ 7;
12890 char *salt_pos
= strchr (iter_pos
, '$');
12892 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12896 char *hash_pos
= strchr (salt_pos
, '$');
12898 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12900 uint salt_len
= hash_pos
- salt_pos
;
12902 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12904 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12906 salt
->salt_len
= salt_len
;
12908 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12910 salt
->salt_sign
[0] = atoi (salt_iter
);
12912 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12916 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12918 digest
[0] = byte_swap_32 (digest
[0]);
12919 digest
[1] = byte_swap_32 (digest
[1]);
12920 digest
[2] = byte_swap_32 (digest
[2]);
12921 digest
[3] = byte_swap_32 (digest
[3]);
12922 digest
[4] = byte_swap_32 (digest
[4]);
12924 return (PARSER_OK
);
12927 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12929 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12931 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12933 u32
*digest
= (u32
*) hash_buf
->digest
;
12935 salt_t
*salt
= hash_buf
->salt
;
12937 char *iter_pos
= input_buf
+ 9;
12939 char *salt_pos
= strchr (iter_pos
, '$');
12941 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12945 char *hash_pos
= strchr (salt_pos
, '$');
12947 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12949 uint salt_len
= hash_pos
- salt_pos
;
12951 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12953 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12955 salt
->salt_len
= salt_len
;
12957 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12959 salt
->salt_sign
[0] = atoi (salt_iter
);
12961 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12965 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12967 digest
[0] = byte_swap_32 (digest
[0]);
12968 digest
[1] = byte_swap_32 (digest
[1]);
12969 digest
[2] = byte_swap_32 (digest
[2]);
12970 digest
[3] = byte_swap_32 (digest
[3]);
12971 digest
[4] = byte_swap_32 (digest
[4]);
12972 digest
[5] = byte_swap_32 (digest
[5]);
12973 digest
[6] = byte_swap_32 (digest
[6]);
12974 digest
[7] = byte_swap_32 (digest
[7]);
12976 return (PARSER_OK
);
12979 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12981 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12983 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12985 u64
*digest
= (u64
*) hash_buf
->digest
;
12987 salt_t
*salt
= hash_buf
->salt
;
12989 char *iter_pos
= input_buf
+ 9;
12991 char *salt_pos
= strchr (iter_pos
, '$');
12993 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12997 char *hash_pos
= strchr (salt_pos
, '$');
12999 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13001 uint salt_len
= hash_pos
- salt_pos
;
13003 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13005 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13007 salt
->salt_len
= salt_len
;
13009 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13011 salt
->salt_sign
[0] = atoi (salt_iter
);
13013 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13017 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13019 digest
[0] = byte_swap_64 (digest
[0]);
13020 digest
[1] = byte_swap_64 (digest
[1]);
13021 digest
[2] = byte_swap_64 (digest
[2]);
13022 digest
[3] = byte_swap_64 (digest
[3]);
13023 digest
[4] = byte_swap_64 (digest
[4]);
13024 digest
[5] = byte_swap_64 (digest
[5]);
13025 digest
[6] = byte_swap_64 (digest
[6]);
13026 digest
[7] = byte_swap_64 (digest
[7]);
13028 return (PARSER_OK
);
13031 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13033 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13035 u32
*digest
= (u32
*) hash_buf
->digest
;
13037 salt_t
*salt
= hash_buf
->salt
;
13039 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13045 char *iterations_pos
= input_buf
;
13047 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13049 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13051 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13053 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13057 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13059 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13061 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13063 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13065 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13067 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13072 * pbkdf2 iterations
13075 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13078 * handle salt encoding
13081 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13083 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13085 const char p0
= saltbuf_pos
[i
+ 0];
13086 const char p1
= saltbuf_pos
[i
+ 1];
13088 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13089 | hex_convert (p0
) << 4;
13092 salt
->salt_len
= saltbuf_len
/ 2;
13095 * handle cipher encoding
13098 uint
*tmp
= (uint
*) mymalloc (32);
13100 char *cipherbuf_ptr
= (char *) tmp
;
13102 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13104 const char p0
= cipherbuf_pos
[i
+ 0];
13105 const char p1
= cipherbuf_pos
[i
+ 1];
13107 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13108 | hex_convert (p0
) << 4;
13111 // iv is stored at salt_buf 4 (length 16)
13112 // data is stored at salt_buf 8 (length 16)
13114 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13115 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13116 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13117 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13119 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13120 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13121 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13122 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13126 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13128 const char p0
= cipherbuf_pos
[j
+ 0];
13129 const char p1
= cipherbuf_pos
[j
+ 1];
13131 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13132 | hex_convert (p0
) << 4;
13139 digest
[0] = 0x10101010;
13140 digest
[1] = 0x10101010;
13141 digest
[2] = 0x10101010;
13142 digest
[3] = 0x10101010;
13144 return (PARSER_OK
);
13147 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13149 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13151 u32
*digest
= (u32
*) hash_buf
->digest
;
13153 salt_t
*salt
= hash_buf
->salt
;
13155 char *hashbuf_pos
= input_buf
;
13157 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13159 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13161 uint hash_len
= iterations_pos
- hashbuf_pos
;
13163 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13167 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13169 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13171 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13175 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13177 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13181 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13185 salt
->salt_len
= salt_len
;
13187 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13189 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13190 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13191 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13192 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13194 return (PARSER_OK
);
13197 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13199 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13201 u32
*digest
= (u32
*) hash_buf
->digest
;
13203 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13204 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13205 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13206 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13207 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13208 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13209 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13210 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13212 digest
[0] = byte_swap_32 (digest
[0]);
13213 digest
[1] = byte_swap_32 (digest
[1]);
13214 digest
[2] = byte_swap_32 (digest
[2]);
13215 digest
[3] = byte_swap_32 (digest
[3]);
13216 digest
[4] = byte_swap_32 (digest
[4]);
13217 digest
[5] = byte_swap_32 (digest
[5]);
13218 digest
[6] = byte_swap_32 (digest
[6]);
13219 digest
[7] = byte_swap_32 (digest
[7]);
13221 return (PARSER_OK
);
13224 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13226 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13228 u32
*digest
= (u32
*) hash_buf
->digest
;
13230 salt_t
*salt
= hash_buf
->salt
;
13232 char *salt_pos
= input_buf
+ 3;
13234 uint iterations_len
= 0;
13236 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13240 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13242 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13243 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13247 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13251 iterations_len
+= 8;
13255 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13258 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13260 char *hash_pos
= strchr (salt_pos
, '$');
13262 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13264 uint salt_len
= hash_pos
- salt_pos
;
13266 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13268 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13270 salt
->salt_len
= salt_len
;
13274 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13276 return (PARSER_OK
);
13279 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13281 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13283 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13285 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13287 u64
*digest
= (u64
*) hash_buf
->digest
;
13289 salt_t
*salt
= hash_buf
->salt
;
13291 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13293 char *iter_pos
= input_buf
+ 4;
13295 char *salt_pos
= strchr (iter_pos
, '$');
13297 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13301 char *hash_pos
= strchr (salt_pos
, '$');
13303 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13305 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13309 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13310 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13311 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13312 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13313 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13314 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13315 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13316 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13318 uint salt_len
= hash_pos
- salt_pos
- 1;
13320 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13322 salt
->salt_len
= salt_len
/ 2;
13324 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13325 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13326 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13327 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13328 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13329 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13330 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13331 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13333 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13334 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13335 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13336 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13337 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13338 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13339 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13340 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13341 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13342 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13344 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13346 salt
->salt_iter
= atoi (iter_pos
) - 1;
13348 return (PARSER_OK
);
13351 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13353 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13355 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13357 u32
*digest
= (u32
*) hash_buf
->digest
;
13359 salt_t
*salt
= hash_buf
->salt
;
13361 char *salt_pos
= input_buf
+ 14;
13363 char *hash_pos
= strchr (salt_pos
, '*');
13365 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13369 uint salt_len
= hash_pos
- salt_pos
- 1;
13371 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13373 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13375 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13377 salt
->salt_len
= salt_len
;
13379 u8 tmp_buf
[100] = { 0 };
13381 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13383 memcpy (digest
, tmp_buf
, 32);
13385 digest
[0] = byte_swap_32 (digest
[0]);
13386 digest
[1] = byte_swap_32 (digest
[1]);
13387 digest
[2] = byte_swap_32 (digest
[2]);
13388 digest
[3] = byte_swap_32 (digest
[3]);
13389 digest
[4] = byte_swap_32 (digest
[4]);
13390 digest
[5] = byte_swap_32 (digest
[5]);
13391 digest
[6] = byte_swap_32 (digest
[6]);
13392 digest
[7] = byte_swap_32 (digest
[7]);
13394 digest
[0] -= SHA256M_A
;
13395 digest
[1] -= SHA256M_B
;
13396 digest
[2] -= SHA256M_C
;
13397 digest
[3] -= SHA256M_D
;
13398 digest
[4] -= SHA256M_E
;
13399 digest
[5] -= SHA256M_F
;
13400 digest
[6] -= SHA256M_G
;
13401 digest
[7] -= SHA256M_H
;
13403 return (PARSER_OK
);
13406 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13408 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13410 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13412 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13414 u64
*digest
= (u64
*) hash_buf
->digest
;
13416 salt_t
*salt
= hash_buf
->salt
;
13418 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13420 char *iter_pos
= input_buf
+ 19;
13422 char *salt_pos
= strchr (iter_pos
, '.');
13424 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13428 char *hash_pos
= strchr (salt_pos
, '.');
13430 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13432 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13436 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13437 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13438 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13439 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13440 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13441 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13442 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13443 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13445 uint salt_len
= hash_pos
- salt_pos
- 1;
13449 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13453 for (i
= 0; i
< salt_len
; i
++)
13455 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13458 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13459 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13461 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13463 salt
->salt_len
= salt_len
;
13465 salt
->salt_iter
= atoi (iter_pos
) - 1;
13467 return (PARSER_OK
);
13470 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13472 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13474 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13476 u64
*digest
= (u64
*) hash_buf
->digest
;
13478 salt_t
*salt
= hash_buf
->salt
;
13480 u8 tmp_buf
[120] = { 0 };
13482 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13484 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13486 memcpy (digest
, tmp_buf
, 64);
13488 digest
[0] = byte_swap_64 (digest
[0]);
13489 digest
[1] = byte_swap_64 (digest
[1]);
13490 digest
[2] = byte_swap_64 (digest
[2]);
13491 digest
[3] = byte_swap_64 (digest
[3]);
13492 digest
[4] = byte_swap_64 (digest
[4]);
13493 digest
[5] = byte_swap_64 (digest
[5]);
13494 digest
[6] = byte_swap_64 (digest
[6]);
13495 digest
[7] = byte_swap_64 (digest
[7]);
13497 digest
[0] -= SHA512M_A
;
13498 digest
[1] -= SHA512M_B
;
13499 digest
[2] -= SHA512M_C
;
13500 digest
[3] -= SHA512M_D
;
13501 digest
[4] -= SHA512M_E
;
13502 digest
[5] -= SHA512M_F
;
13503 digest
[6] -= SHA512M_G
;
13504 digest
[7] -= SHA512M_H
;
13506 int salt_len
= tmp_len
- 64;
13508 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13510 salt
->salt_len
= salt_len
;
13512 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13514 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13516 char *ptr
= (char *) salt
->salt_buf
;
13518 ptr
[salt
->salt_len
] = 0x80;
13521 return (PARSER_OK
);
13524 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13526 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13528 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13532 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13535 u32
*digest
= (u32
*) hash_buf
->digest
;
13537 salt_t
*salt
= hash_buf
->salt
;
13539 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13540 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13541 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13542 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13544 digest
[0] = byte_swap_32 (digest
[0]);
13545 digest
[1] = byte_swap_32 (digest
[1]);
13546 digest
[2] = byte_swap_32 (digest
[2]);
13547 digest
[3] = byte_swap_32 (digest
[3]);
13549 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13551 uint salt_len
= input_len
- 32 - 1;
13553 char *salt_buf
= input_buf
+ 32 + 1;
13555 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13557 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13559 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13561 salt
->salt_len
= salt_len
;
13563 return (PARSER_OK
);
13566 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13570 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13574 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13577 u32
*digest
= (u32
*) hash_buf
->digest
;
13579 salt_t
*salt
= hash_buf
->salt
;
13581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13585 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13587 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13589 uint salt_len
= input_len
- 40 - 1;
13591 char *salt_buf
= input_buf
+ 40 + 1;
13593 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13595 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13597 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13599 salt
->salt_len
= salt_len
;
13601 return (PARSER_OK
);
13604 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13606 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13608 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13612 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13615 u32
*digest
= (u32
*) hash_buf
->digest
;
13617 salt_t
*salt
= hash_buf
->salt
;
13619 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13620 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13621 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13622 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13623 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13624 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13625 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13626 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13628 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13630 uint salt_len
= input_len
- 64 - 1;
13632 char *salt_buf
= input_buf
+ 64 + 1;
13634 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13636 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13638 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13640 salt
->salt_len
= salt_len
;
13642 return (PARSER_OK
);
13645 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13647 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13649 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13653 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13656 u64
*digest
= (u64
*) hash_buf
->digest
;
13658 salt_t
*salt
= hash_buf
->salt
;
13660 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13661 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13662 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13663 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13664 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13665 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13666 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13667 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13669 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13671 uint salt_len
= input_len
- 128 - 1;
13673 char *salt_buf
= input_buf
+ 128 + 1;
13675 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13677 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13679 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13681 salt
->salt_len
= salt_len
;
13683 return (PARSER_OK
);
13686 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13688 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13690 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13692 u32
*digest
= (u32
*) hash_buf
->digest
;
13694 salt_t
*salt
= hash_buf
->salt
;
13696 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13702 char *user_pos
= input_buf
+ 10 + 1;
13704 char *realm_pos
= strchr (user_pos
, '$');
13706 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13708 uint user_len
= realm_pos
- user_pos
;
13710 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13714 char *salt_pos
= strchr (realm_pos
, '$');
13716 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13718 uint realm_len
= salt_pos
- realm_pos
;
13720 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13724 char *data_pos
= strchr (salt_pos
, '$');
13726 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13728 uint salt_len
= data_pos
- salt_pos
;
13730 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13734 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13736 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13742 memcpy (krb5pa
->user
, user_pos
, user_len
);
13743 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13744 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13746 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13748 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13750 const char p0
= data_pos
[i
+ 0];
13751 const char p1
= data_pos
[i
+ 1];
13753 *timestamp_ptr
++ = hex_convert (p1
) << 0
13754 | hex_convert (p0
) << 4;
13757 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13759 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13761 const char p0
= data_pos
[i
+ 0];
13762 const char p1
= data_pos
[i
+ 1];
13764 *checksum_ptr
++ = hex_convert (p1
) << 0
13765 | hex_convert (p0
) << 4;
13769 * copy some data to generic buffers to make sorting happy
13772 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13773 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13774 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13775 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13776 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13777 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13778 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13779 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13780 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13782 salt
->salt_len
= 36;
13784 digest
[0] = krb5pa
->checksum
[0];
13785 digest
[1] = krb5pa
->checksum
[1];
13786 digest
[2] = krb5pa
->checksum
[2];
13787 digest
[3] = krb5pa
->checksum
[3];
13789 return (PARSER_OK
);
13792 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13794 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13796 u32
*digest
= (u32
*) hash_buf
->digest
;
13798 salt_t
*salt
= hash_buf
->salt
;
13804 char *salt_pos
= input_buf
;
13806 char *hash_pos
= strchr (salt_pos
, '$');
13808 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13810 uint salt_len
= hash_pos
- salt_pos
;
13812 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13816 uint hash_len
= input_len
- 1 - salt_len
;
13818 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13826 for (uint i
= 0; i
< salt_len
; i
++)
13828 if (salt_pos
[i
] == ' ') continue;
13833 // SAP user names cannot be longer than 12 characters
13834 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13836 // SAP user name cannot start with ! or ?
13837 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13843 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13845 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13847 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13849 salt
->salt_len
= salt_len
;
13851 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13852 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13856 digest
[0] = byte_swap_32 (digest
[0]);
13857 digest
[1] = byte_swap_32 (digest
[1]);
13859 return (PARSER_OK
);
13862 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13864 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13866 u32
*digest
= (u32
*) hash_buf
->digest
;
13868 salt_t
*salt
= hash_buf
->salt
;
13874 char *salt_pos
= input_buf
;
13876 char *hash_pos
= strchr (salt_pos
, '$');
13878 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13880 uint salt_len
= hash_pos
- salt_pos
;
13882 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13886 uint hash_len
= input_len
- 1 - salt_len
;
13888 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13896 for (uint i
= 0; i
< salt_len
; i
++)
13898 if (salt_pos
[i
] == ' ') continue;
13903 // SAP user names cannot be longer than 12 characters
13904 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13905 // so far nobody complained so we stay with this because it helps in optimization
13906 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13908 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13910 // SAP user name cannot start with ! or ?
13911 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13917 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13919 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13921 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13923 salt
->salt_len
= salt_len
;
13925 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13926 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13927 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13928 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13929 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13931 return (PARSER_OK
);
13934 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13936 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13938 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13940 u64
*digest
= (u64
*) hash_buf
->digest
;
13942 salt_t
*salt
= hash_buf
->salt
;
13944 char *iter_pos
= input_buf
+ 3;
13946 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13948 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13950 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13952 salt
->salt_iter
= salt_iter
;
13954 char *salt_pos
= iter_pos
+ 1;
13958 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13960 salt
->salt_len
= salt_len
;
13962 char *hash_pos
= salt_pos
+ salt_len
;
13964 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13968 char *tmp
= (char *) salt
->salt_buf_pc
;
13970 tmp
[0] = hash_pos
[42];
13974 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13975 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13976 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13977 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13983 return (PARSER_OK
);
13986 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13988 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13990 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13992 u32
*digest
= (u32
*) hash_buf
->digest
;
13994 salt_t
*salt
= hash_buf
->salt
;
13996 char *salt_buf
= input_buf
+ 6;
13998 uint salt_len
= 16;
14000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14006 salt
->salt_len
= salt_len
;
14008 char *hash_pos
= input_buf
+ 6 + 16;
14010 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14011 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14012 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14013 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14014 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14015 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14016 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14017 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14019 return (PARSER_OK
);
14022 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14024 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14026 u32
*digest
= (u32
*) hash_buf
->digest
;
14028 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14029 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14033 return (PARSER_OK
);
14036 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14038 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14040 u32
*digest
= (u32
*) hash_buf
->digest
;
14042 salt_t
*salt
= hash_buf
->salt
;
14044 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14046 char *saltbuf_pos
= input_buf
;
14048 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14050 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14052 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14054 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14055 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14057 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14061 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14063 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14065 char *salt_ptr
= (char *) saltbuf_pos
;
14066 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14071 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14073 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14076 rakp_ptr
[j
] = 0x80;
14078 rakp
->salt_len
= j
;
14080 for (i
= 0; i
< 64; i
++)
14082 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14085 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14086 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14087 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14088 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14089 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14090 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14091 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14092 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14094 salt
->salt_len
= 32; // muss min. 32 haben
14096 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14097 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14098 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14099 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14100 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14102 return (PARSER_OK
);
14105 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14107 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14109 u32
*digest
= (u32
*) hash_buf
->digest
;
14111 salt_t
*salt
= hash_buf
->salt
;
14113 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14115 char *salt_pos
= input_buf
+ 1;
14117 memcpy (salt
->salt_buf
, salt_pos
, 8);
14119 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14120 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14122 salt
->salt_len
= 8;
14124 char *hash_pos
= salt_pos
+ 8;
14126 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14127 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14128 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14129 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14130 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14132 digest
[0] -= SHA1M_A
;
14133 digest
[1] -= SHA1M_B
;
14134 digest
[2] -= SHA1M_C
;
14135 digest
[3] -= SHA1M_D
;
14136 digest
[4] -= SHA1M_E
;
14138 return (PARSER_OK
);
14141 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14143 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14145 u32
*digest
= (u32
*) hash_buf
->digest
;
14147 salt_t
*salt
= hash_buf
->salt
;
14149 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14150 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14151 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14152 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14154 digest
[0] = byte_swap_32 (digest
[0]);
14155 digest
[1] = byte_swap_32 (digest
[1]);
14156 digest
[2] = byte_swap_32 (digest
[2]);
14157 digest
[3] = byte_swap_32 (digest
[3]);
14159 digest
[0] -= MD5M_A
;
14160 digest
[1] -= MD5M_B
;
14161 digest
[2] -= MD5M_C
;
14162 digest
[3] -= MD5M_D
;
14164 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14166 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14168 u32
*salt_buf
= salt
->salt_buf
;
14170 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14171 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14172 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14173 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14175 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14176 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14177 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14178 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14180 salt
->salt_len
= 16 + 1;
14182 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14184 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14186 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14188 return (PARSER_OK
);
14191 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14193 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14195 u32
*digest
= (u32
*) hash_buf
->digest
;
14197 salt_t
*salt
= hash_buf
->salt
;
14199 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14205 char *hashbuf_pos
= input_buf
;
14207 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14209 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14211 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14213 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14217 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14219 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14221 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14223 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14227 char *databuf_pos
= strchr (iteration_pos
, ':');
14229 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14231 const uint iteration_len
= databuf_pos
- iteration_pos
;
14233 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14234 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14236 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14238 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14239 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14245 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14246 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14247 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14248 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14249 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14250 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14251 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14252 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14256 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14258 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14260 const char p0
= saltbuf_pos
[i
+ 0];
14261 const char p1
= saltbuf_pos
[i
+ 1];
14263 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14264 | hex_convert (p0
) << 4;
14267 salt
->salt_buf
[4] = 0x01000000;
14268 salt
->salt_buf
[5] = 0x80;
14270 salt
->salt_len
= saltbuf_len
/ 2;
14274 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14278 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14280 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14282 const char p0
= databuf_pos
[i
+ 0];
14283 const char p1
= databuf_pos
[i
+ 1];
14285 *databuf_ptr
++ = hex_convert (p1
) << 0
14286 | hex_convert (p0
) << 4;
14289 *databuf_ptr
++ = 0x80;
14291 for (uint i
= 0; i
< 512; i
++)
14293 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14296 cloudkey
->data_len
= databuf_len
/ 2;
14298 return (PARSER_OK
);
14301 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14303 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14305 u32
*digest
= (u32
*) hash_buf
->digest
;
14307 salt_t
*salt
= hash_buf
->salt
;
14313 char *hashbuf_pos
= input_buf
;
14315 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14317 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14319 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14321 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14325 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14327 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14329 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14331 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14333 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14337 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14339 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14341 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14343 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14345 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14349 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14351 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14352 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14354 // ok, the plan for this algorithm is the following:
14355 // we have 2 salts here, the domain-name and a random salt
14356 // while both are used in the initial transformation,
14357 // only the random salt is used in the following iterations
14358 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14359 // and one that includes only the real salt (stored into salt_buf[]).
14360 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14362 u8 tmp_buf
[100] = { 0 };
14364 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14366 memcpy (digest
, tmp_buf
, 20);
14368 digest
[0] = byte_swap_32 (digest
[0]);
14369 digest
[1] = byte_swap_32 (digest
[1]);
14370 digest
[2] = byte_swap_32 (digest
[2]);
14371 digest
[3] = byte_swap_32 (digest
[3]);
14372 digest
[4] = byte_swap_32 (digest
[4]);
14376 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14378 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14380 char *len_ptr
= NULL
;
14382 for (uint i
= 0; i
< domainbuf_len
; i
++)
14384 if (salt_buf_pc_ptr
[i
] == '.')
14386 len_ptr
= &salt_buf_pc_ptr
[i
];
14396 salt
->salt_buf_pc
[7] = domainbuf_len
;
14400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14402 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14404 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14406 salt
->salt_len
= salt_len
;
14410 salt
->salt_iter
= atoi (iteration_pos
);
14412 return (PARSER_OK
);
14415 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14417 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14419 u32
*digest
= (u32
*) hash_buf
->digest
;
14421 salt_t
*salt
= hash_buf
->salt
;
14423 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14424 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14425 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14426 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14427 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14429 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14431 uint salt_len
= input_len
- 40 - 1;
14433 char *salt_buf
= input_buf
+ 40 + 1;
14435 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14437 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14439 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14441 salt
->salt_len
= salt_len
;
14443 return (PARSER_OK
);
14446 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14448 const u8 ascii_to_ebcdic
[] =
14450 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14451 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14452 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14453 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14454 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14455 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14456 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14457 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14458 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14459 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14460 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14461 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14462 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14463 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14464 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14465 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14468 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14470 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14472 u32
*digest
= (u32
*) hash_buf
->digest
;
14474 salt_t
*salt
= hash_buf
->salt
;
14476 char *salt_pos
= input_buf
+ 6 + 1;
14478 char *digest_pos
= strchr (salt_pos
, '*');
14480 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14482 uint salt_len
= digest_pos
- salt_pos
;
14484 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14486 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14488 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14493 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14495 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14497 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14499 salt
->salt_len
= salt_len
;
14501 for (uint i
= 0; i
< salt_len
; i
++)
14503 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14505 for (uint i
= salt_len
; i
< 8; i
++)
14507 salt_buf_pc_ptr
[i
] = 0x40;
14512 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14514 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14515 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14517 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14518 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14520 digest
[0] = byte_swap_32 (digest
[0]);
14521 digest
[1] = byte_swap_32 (digest
[1]);
14523 IP (digest
[0], digest
[1], tt
);
14525 digest
[0] = rotr32 (digest
[0], 29);
14526 digest
[1] = rotr32 (digest
[1], 29);
14530 return (PARSER_OK
);
14533 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14535 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14537 u32
*digest
= (u32
*) hash_buf
->digest
;
14539 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14540 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14541 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14542 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14544 digest
[0] = byte_swap_32 (digest
[0]);
14545 digest
[1] = byte_swap_32 (digest
[1]);
14546 digest
[2] = byte_swap_32 (digest
[2]);
14547 digest
[3] = byte_swap_32 (digest
[3]);
14549 return (PARSER_OK
);
14552 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14554 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14556 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14558 u32
*digest
= (u32
*) hash_buf
->digest
;
14560 salt_t
*salt
= hash_buf
->salt
;
14562 u8 tmp_buf
[120] = { 0 };
14564 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14566 tmp_buf
[3] += -4; // dont ask!
14568 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14570 salt
->salt_len
= 5;
14572 memcpy (digest
, tmp_buf
+ 5, 9);
14574 // yes, only 9 byte are needed to crack, but 10 to display
14576 salt
->salt_buf_pc
[7] = input_buf
[20];
14578 return (PARSER_OK
);
14581 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14583 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14585 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14587 u32
*digest
= (u32
*) hash_buf
->digest
;
14589 salt_t
*salt
= hash_buf
->salt
;
14591 u8 tmp_buf
[120] = { 0 };
14593 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14595 tmp_buf
[3] += -4; // dont ask!
14599 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14601 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)
14605 char tmp_iter_buf
[11] = { 0 };
14607 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14609 tmp_iter_buf
[10] = 0;
14611 salt
->salt_iter
= atoi (tmp_iter_buf
);
14613 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14615 return (PARSER_SALT_ITERATION
);
14618 salt
->salt_iter
--; // first round in init
14620 // 2 additional bytes for display only
14622 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14623 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14627 memcpy (digest
, tmp_buf
+ 28, 8);
14629 digest
[0] = byte_swap_32 (digest
[0]);
14630 digest
[1] = byte_swap_32 (digest
[1]);
14634 return (PARSER_OK
);
14637 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14639 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14641 u32
*digest
= (u32
*) hash_buf
->digest
;
14643 salt_t
*salt
= hash_buf
->salt
;
14645 char *salt_buf_pos
= input_buf
;
14647 char *hash_buf_pos
= salt_buf_pos
+ 6;
14649 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14650 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14651 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14652 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14653 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14654 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14655 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14656 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14658 digest
[0] -= SHA256M_A
;
14659 digest
[1] -= SHA256M_B
;
14660 digest
[2] -= SHA256M_C
;
14661 digest
[3] -= SHA256M_D
;
14662 digest
[4] -= SHA256M_E
;
14663 digest
[5] -= SHA256M_F
;
14664 digest
[6] -= SHA256M_G
;
14665 digest
[7] -= SHA256M_H
;
14667 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14669 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14671 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14673 salt
->salt_len
= salt_len
;
14675 return (PARSER_OK
);
14678 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14680 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14682 u32
*digest
= (u32
*) hash_buf
->digest
;
14684 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14686 salt_t
*salt
= hash_buf
->salt
;
14688 char *salt_buf
= input_buf
+ 6;
14690 char *digest_buf
= strchr (salt_buf
, '$');
14692 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14694 uint salt_len
= digest_buf
- salt_buf
;
14696 digest_buf
++; // skip the '$' symbol
14698 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14700 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14702 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14704 salt
->salt_len
= salt_len
;
14706 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14707 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14708 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14709 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14711 digest
[0] = byte_swap_32 (digest
[0]);
14712 digest
[1] = byte_swap_32 (digest
[1]);
14713 digest
[2] = byte_swap_32 (digest
[2]);
14714 digest
[3] = byte_swap_32 (digest
[3]);
14716 digest
[0] -= MD5M_A
;
14717 digest
[1] -= MD5M_B
;
14718 digest
[2] -= MD5M_C
;
14719 digest
[3] -= MD5M_D
;
14721 return (PARSER_OK
);
14724 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14726 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14728 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14730 u32
*digest
= (u32
*) hash_buf
->digest
;
14732 salt_t
*salt
= hash_buf
->salt
;
14734 char *salt_buf
= input_buf
+ 3;
14736 char *digest_buf
= strchr (salt_buf
, '$');
14738 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14740 uint salt_len
= digest_buf
- salt_buf
;
14742 digest_buf
++; // skip the '$' symbol
14744 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14746 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14748 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14750 salt_buf_ptr
[salt_len
] = 0x2d;
14752 salt
->salt_len
= salt_len
+ 1;
14754 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14755 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14756 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14757 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14759 digest
[0] = byte_swap_32 (digest
[0]);
14760 digest
[1] = byte_swap_32 (digest
[1]);
14761 digest
[2] = byte_swap_32 (digest
[2]);
14762 digest
[3] = byte_swap_32 (digest
[3]);
14764 digest
[0] -= MD5M_A
;
14765 digest
[1] -= MD5M_B
;
14766 digest
[2] -= MD5M_C
;
14767 digest
[3] -= MD5M_D
;
14769 return (PARSER_OK
);
14772 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14774 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14776 u32
*digest
= (u32
*) hash_buf
->digest
;
14778 salt_t
*salt
= hash_buf
->salt
;
14780 u8 tmp_buf
[100] = { 0 };
14782 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14784 memcpy (digest
, tmp_buf
, 20);
14786 digest
[0] = byte_swap_32 (digest
[0]);
14787 digest
[1] = byte_swap_32 (digest
[1]);
14788 digest
[2] = byte_swap_32 (digest
[2]);
14789 digest
[3] = byte_swap_32 (digest
[3]);
14790 digest
[4] = byte_swap_32 (digest
[4]);
14792 digest
[0] -= SHA1M_A
;
14793 digest
[1] -= SHA1M_B
;
14794 digest
[2] -= SHA1M_C
;
14795 digest
[3] -= SHA1M_D
;
14796 digest
[4] -= SHA1M_E
;
14798 salt
->salt_buf
[0] = 0x80;
14800 salt
->salt_len
= 0;
14802 return (PARSER_OK
);
14805 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14807 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14809 u32
*digest
= (u32
*) hash_buf
->digest
;
14811 salt_t
*salt
= hash_buf
->salt
;
14813 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14814 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14815 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14816 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14818 digest
[0] = byte_swap_32 (digest
[0]);
14819 digest
[1] = byte_swap_32 (digest
[1]);
14820 digest
[2] = byte_swap_32 (digest
[2]);
14821 digest
[3] = byte_swap_32 (digest
[3]);
14823 digest
[0] -= MD5M_A
;
14824 digest
[1] -= MD5M_B
;
14825 digest
[2] -= MD5M_C
;
14826 digest
[3] -= MD5M_D
;
14828 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14830 uint salt_len
= input_len
- 32 - 1;
14832 char *salt_buf
= input_buf
+ 32 + 1;
14834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14836 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14841 * add static "salt" part
14844 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14848 salt
->salt_len
= salt_len
;
14850 return (PARSER_OK
);
14853 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14855 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14857 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14859 u32
*digest
= (u32
*) hash_buf
->digest
;
14861 salt_t
*salt
= hash_buf
->salt
;
14863 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14869 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14871 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14873 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14875 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14877 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14881 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14883 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14885 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14887 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14891 char *keybuf_pos
= strchr (keylen_pos
, '$');
14893 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14895 uint keylen_len
= keybuf_pos
- keylen_pos
;
14897 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14901 char *databuf_pos
= strchr (keybuf_pos
, '$');
14903 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14907 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14911 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14913 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14919 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14920 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14921 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14922 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14924 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14925 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14926 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14927 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14929 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14930 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14931 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14932 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14934 salt
->salt_len
= 16;
14935 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14937 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14939 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14942 return (PARSER_OK
);
14945 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14947 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14949 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14951 u32
*digest
= (u32
*) hash_buf
->digest
;
14953 salt_t
*salt
= hash_buf
->salt
;
14959 // first is the N salt parameter
14961 char *N_pos
= input_buf
+ 6;
14963 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14967 salt
->scrypt_N
= atoi (N_pos
);
14971 char *r_pos
= strchr (N_pos
, ':');
14973 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14977 salt
->scrypt_r
= atoi (r_pos
);
14981 char *p_pos
= strchr (r_pos
, ':');
14983 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14987 salt
->scrypt_p
= atoi (p_pos
);
14991 char *saltbuf_pos
= strchr (p_pos
, ':');
14993 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14997 char *hash_pos
= strchr (saltbuf_pos
, ':');
14999 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15005 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15007 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15009 u8 tmp_buf
[33] = { 0 };
15011 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15013 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15015 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15017 salt
->salt_len
= tmp_len
;
15018 salt
->salt_iter
= 1;
15020 // digest - base64 decode
15022 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15024 tmp_len
= input_len
- (hash_pos
- input_buf
);
15026 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15028 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15030 memcpy (digest
, tmp_buf
, 32);
15032 return (PARSER_OK
);
15035 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15037 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15039 u32
*digest
= (u32
*) hash_buf
->digest
;
15041 salt_t
*salt
= hash_buf
->salt
;
15047 char decrypted
[76] = { 0 }; // iv + hash
15049 juniper_decrypt_hash (input_buf
, decrypted
);
15051 char *md5crypt_hash
= decrypted
+ 12;
15053 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15055 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15057 char *salt_pos
= md5crypt_hash
+ 3;
15059 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15061 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15063 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15067 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15069 return (PARSER_OK
);
15072 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15074 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15076 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15078 u32
*digest
= (u32
*) hash_buf
->digest
;
15080 salt_t
*salt
= hash_buf
->salt
;
15082 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15088 // first is *raw* salt
15090 char *salt_pos
= input_buf
+ 3;
15092 char *hash_pos
= strchr (salt_pos
, '$');
15094 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15096 uint salt_len
= hash_pos
- salt_pos
;
15098 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15102 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15104 memcpy (salt_buf_ptr
, salt_pos
, 14);
15106 salt_buf_ptr
[17] = 0x01;
15107 salt_buf_ptr
[18] = 0x80;
15109 // add some stuff to normal salt to make sorted happy
15111 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15112 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15113 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15114 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15116 salt
->salt_len
= salt_len
;
15117 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15119 // base64 decode hash
15121 u8 tmp_buf
[100] = { 0 };
15123 uint hash_len
= input_len
- 3 - salt_len
- 1;
15125 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15127 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15129 memcpy (digest
, tmp_buf
, 32);
15131 digest
[0] = byte_swap_32 (digest
[0]);
15132 digest
[1] = byte_swap_32 (digest
[1]);
15133 digest
[2] = byte_swap_32 (digest
[2]);
15134 digest
[3] = byte_swap_32 (digest
[3]);
15135 digest
[4] = byte_swap_32 (digest
[4]);
15136 digest
[5] = byte_swap_32 (digest
[5]);
15137 digest
[6] = byte_swap_32 (digest
[6]);
15138 digest
[7] = byte_swap_32 (digest
[7]);
15140 return (PARSER_OK
);
15143 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15145 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15147 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15149 u32
*digest
= (u32
*) hash_buf
->digest
;
15151 salt_t
*salt
= hash_buf
->salt
;
15157 // first is *raw* salt
15159 char *salt_pos
= input_buf
+ 3;
15161 char *hash_pos
= strchr (salt_pos
, '$');
15163 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15165 uint salt_len
= hash_pos
- salt_pos
;
15167 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15169 salt
->salt_len
= salt_len
;
15172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15174 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15175 salt_buf_ptr
[salt_len
] = 0;
15177 // base64 decode hash
15179 u8 tmp_buf
[100] = { 0 };
15181 uint hash_len
= input_len
- 3 - salt_len
- 1;
15183 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15185 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15187 memcpy (digest
, tmp_buf
, 32);
15190 salt
->scrypt_N
= 16384;
15191 salt
->scrypt_r
= 1;
15192 salt
->scrypt_p
= 1;
15193 salt
->salt_iter
= 1;
15195 return (PARSER_OK
);
15198 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15200 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15202 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15204 u32
*digest
= (u32
*) hash_buf
->digest
;
15206 salt_t
*salt
= hash_buf
->salt
;
15208 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15214 char *version_pos
= input_buf
+ 8 + 1;
15216 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15218 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15220 u32 version_len
= verifierHashSize_pos
- version_pos
;
15222 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15224 verifierHashSize_pos
++;
15226 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15228 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15230 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15232 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15236 char *saltSize_pos
= strchr (keySize_pos
, '*');
15238 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15240 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15242 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15246 char *osalt_pos
= strchr (saltSize_pos
, '*');
15248 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15250 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15252 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15256 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15258 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15260 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15262 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15264 encryptedVerifier_pos
++;
15266 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15268 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15270 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15272 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15274 encryptedVerifierHash_pos
++;
15276 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;
15278 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15280 const uint version
= atoi (version_pos
);
15282 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15284 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15286 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15288 const uint keySize
= atoi (keySize_pos
);
15290 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15292 office2007
->keySize
= keySize
;
15294 const uint saltSize
= atoi (saltSize_pos
);
15296 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15302 salt
->salt_len
= 16;
15303 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15305 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15306 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15307 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15308 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15314 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15315 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15316 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15317 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15319 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15320 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15321 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15322 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15323 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15329 digest
[0] = office2007
->encryptedVerifierHash
[0];
15330 digest
[1] = office2007
->encryptedVerifierHash
[1];
15331 digest
[2] = office2007
->encryptedVerifierHash
[2];
15332 digest
[3] = office2007
->encryptedVerifierHash
[3];
15334 return (PARSER_OK
);
15337 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15339 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15341 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15343 u32
*digest
= (u32
*) hash_buf
->digest
;
15345 salt_t
*salt
= hash_buf
->salt
;
15347 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15353 char *version_pos
= input_buf
+ 8 + 1;
15355 char *spinCount_pos
= strchr (version_pos
, '*');
15357 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15359 u32 version_len
= spinCount_pos
- version_pos
;
15361 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15365 char *keySize_pos
= strchr (spinCount_pos
, '*');
15367 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15369 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15371 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15375 char *saltSize_pos
= strchr (keySize_pos
, '*');
15377 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15379 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15381 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15385 char *osalt_pos
= strchr (saltSize_pos
, '*');
15387 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15389 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15391 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15395 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15397 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15399 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15401 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15403 encryptedVerifier_pos
++;
15405 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15407 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15409 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15411 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15413 encryptedVerifierHash_pos
++;
15415 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;
15417 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15419 const uint version
= atoi (version_pos
);
15421 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15423 const uint spinCount
= atoi (spinCount_pos
);
15425 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15427 const uint keySize
= atoi (keySize_pos
);
15429 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15431 const uint saltSize
= atoi (saltSize_pos
);
15433 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15439 salt
->salt_len
= 16;
15440 salt
->salt_iter
= spinCount
;
15442 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15443 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15444 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15445 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15451 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15452 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15453 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15454 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15456 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15457 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15458 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15459 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15460 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15461 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15462 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15463 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15469 digest
[0] = office2010
->encryptedVerifierHash
[0];
15470 digest
[1] = office2010
->encryptedVerifierHash
[1];
15471 digest
[2] = office2010
->encryptedVerifierHash
[2];
15472 digest
[3] = office2010
->encryptedVerifierHash
[3];
15474 return (PARSER_OK
);
15477 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15479 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15481 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15483 u32
*digest
= (u32
*) hash_buf
->digest
;
15485 salt_t
*salt
= hash_buf
->salt
;
15487 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15493 char *version_pos
= input_buf
+ 8 + 1;
15495 char *spinCount_pos
= strchr (version_pos
, '*');
15497 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 u32 version_len
= spinCount_pos
- version_pos
;
15501 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15505 char *keySize_pos
= strchr (spinCount_pos
, '*');
15507 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15509 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15511 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15515 char *saltSize_pos
= strchr (keySize_pos
, '*');
15517 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15519 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15521 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15525 char *osalt_pos
= strchr (saltSize_pos
, '*');
15527 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15529 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15531 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15535 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15537 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15539 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15541 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15543 encryptedVerifier_pos
++;
15545 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15547 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15549 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15551 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15553 encryptedVerifierHash_pos
++;
15555 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;
15557 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15559 const uint version
= atoi (version_pos
);
15561 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15563 const uint spinCount
= atoi (spinCount_pos
);
15565 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15567 const uint keySize
= atoi (keySize_pos
);
15569 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15571 const uint saltSize
= atoi (saltSize_pos
);
15573 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15579 salt
->salt_len
= 16;
15580 salt
->salt_iter
= spinCount
;
15582 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15583 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15584 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15585 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15591 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15592 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15593 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15594 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15596 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15597 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15598 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15599 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15600 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15601 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15602 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15603 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15609 digest
[0] = office2013
->encryptedVerifierHash
[0];
15610 digest
[1] = office2013
->encryptedVerifierHash
[1];
15611 digest
[2] = office2013
->encryptedVerifierHash
[2];
15612 digest
[3] = office2013
->encryptedVerifierHash
[3];
15614 return (PARSER_OK
);
15617 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15619 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15621 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15623 u32
*digest
= (u32
*) hash_buf
->digest
;
15625 salt_t
*salt
= hash_buf
->salt
;
15627 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15633 char *version_pos
= input_buf
+ 11;
15635 char *osalt_pos
= strchr (version_pos
, '*');
15637 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15639 u32 version_len
= osalt_pos
- version_pos
;
15641 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15645 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15647 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15649 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15651 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15653 encryptedVerifier_pos
++;
15655 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15657 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15659 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15661 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15663 encryptedVerifierHash_pos
++;
15665 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15667 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15669 const uint version
= *version_pos
- 0x30;
15671 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15677 oldoffice01
->version
= version
;
15679 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15680 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15681 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15682 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15684 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15685 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15686 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15687 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15689 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15690 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15691 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15692 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15694 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15695 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15696 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15697 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15703 salt
->salt_len
= 16;
15705 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15706 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15707 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15708 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15710 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15711 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15712 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15713 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15715 // this is a workaround as office produces multiple documents with the same salt
15717 salt
->salt_len
+= 32;
15719 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15720 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15721 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15722 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15723 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15724 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15725 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15726 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15732 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15733 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15734 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15735 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15737 return (PARSER_OK
);
15740 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15742 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15745 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15747 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15749 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15751 u32
*digest
= (u32
*) hash_buf
->digest
;
15753 salt_t
*salt
= hash_buf
->salt
;
15755 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15761 char *version_pos
= input_buf
+ 11;
15763 char *osalt_pos
= strchr (version_pos
, '*');
15765 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 version_len
= osalt_pos
- version_pos
;
15769 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15773 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15775 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15777 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15779 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15781 encryptedVerifier_pos
++;
15783 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15785 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15787 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15789 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15791 encryptedVerifierHash_pos
++;
15793 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15795 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15797 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15799 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15803 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15805 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15807 const uint version
= *version_pos
- 0x30;
15809 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15815 oldoffice01
->version
= version
;
15817 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15818 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15819 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15820 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15822 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15823 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15824 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15825 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15827 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15828 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15829 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15830 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15832 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15833 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15834 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15835 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15837 oldoffice01
->rc4key
[1] = 0;
15838 oldoffice01
->rc4key
[0] = 0;
15840 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15841 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15842 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15843 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15844 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15845 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15846 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15847 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15848 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15849 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15851 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15852 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15858 salt
->salt_len
= 16;
15860 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15861 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15862 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15863 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15865 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15866 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15867 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15868 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15870 // this is a workaround as office produces multiple documents with the same salt
15872 salt
->salt_len
+= 32;
15874 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15875 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15876 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15877 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15878 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15879 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15880 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15881 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15887 digest
[0] = oldoffice01
->rc4key
[0];
15888 digest
[1] = oldoffice01
->rc4key
[1];
15892 return (PARSER_OK
);
15895 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15897 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15899 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15901 u32
*digest
= (u32
*) hash_buf
->digest
;
15903 salt_t
*salt
= hash_buf
->salt
;
15905 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15911 char *version_pos
= input_buf
+ 11;
15913 char *osalt_pos
= strchr (version_pos
, '*');
15915 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 u32 version_len
= osalt_pos
- version_pos
;
15919 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15923 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15925 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15927 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15929 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15931 encryptedVerifier_pos
++;
15933 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15935 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15937 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15939 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15941 encryptedVerifierHash_pos
++;
15943 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15945 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15947 const uint version
= *version_pos
- 0x30;
15949 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15955 oldoffice34
->version
= version
;
15957 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15958 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15959 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15960 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15962 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15963 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15964 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15965 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15967 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15968 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15969 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15970 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15971 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15973 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15974 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15975 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15976 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15977 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15983 salt
->salt_len
= 16;
15985 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15986 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15987 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15988 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15990 // this is a workaround as office produces multiple documents with the same salt
15992 salt
->salt_len
+= 32;
15994 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15995 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15996 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15997 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15998 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15999 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16000 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16001 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16007 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16008 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16009 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16010 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16012 return (PARSER_OK
);
16015 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16017 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16019 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16022 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16024 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16026 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16028 u32
*digest
= (u32
*) hash_buf
->digest
;
16030 salt_t
*salt
= hash_buf
->salt
;
16032 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16038 char *version_pos
= input_buf
+ 11;
16040 char *osalt_pos
= strchr (version_pos
, '*');
16042 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16044 u32 version_len
= osalt_pos
- version_pos
;
16046 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16050 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16052 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16054 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16056 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16058 encryptedVerifier_pos
++;
16060 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16062 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16064 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16066 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16068 encryptedVerifierHash_pos
++;
16070 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16072 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16074 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16076 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16080 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16082 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16084 const uint version
= *version_pos
- 0x30;
16086 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16092 oldoffice34
->version
= version
;
16094 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16095 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16096 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16097 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16099 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16100 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16101 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16102 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16104 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16105 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16106 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16107 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16108 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16110 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16111 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16112 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16113 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16114 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16116 oldoffice34
->rc4key
[1] = 0;
16117 oldoffice34
->rc4key
[0] = 0;
16119 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16120 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16121 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16122 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16123 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16124 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16125 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16126 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16127 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16128 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16130 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16131 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16137 salt
->salt_len
= 16;
16139 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16140 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16141 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16142 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16144 // this is a workaround as office produces multiple documents with the same salt
16146 salt
->salt_len
+= 32;
16148 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16149 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16150 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16151 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16152 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16153 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16154 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16155 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16161 digest
[0] = oldoffice34
->rc4key
[0];
16162 digest
[1] = oldoffice34
->rc4key
[1];
16166 return (PARSER_OK
);
16169 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16171 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16173 u32
*digest
= (u32
*) hash_buf
->digest
;
16175 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16176 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16177 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16178 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16180 digest
[0] = byte_swap_32 (digest
[0]);
16181 digest
[1] = byte_swap_32 (digest
[1]);
16182 digest
[2] = byte_swap_32 (digest
[2]);
16183 digest
[3] = byte_swap_32 (digest
[3]);
16185 return (PARSER_OK
);
16188 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16190 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16192 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16194 u32
*digest
= (u32
*) hash_buf
->digest
;
16196 salt_t
*salt
= hash_buf
->salt
;
16198 char *signature_pos
= input_buf
;
16200 char *salt_pos
= strchr (signature_pos
, '$');
16202 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16204 u32 signature_len
= salt_pos
- signature_pos
;
16206 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16210 char *hash_pos
= strchr (salt_pos
, '$');
16212 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16214 u32 salt_len
= hash_pos
- salt_pos
;
16216 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16220 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16222 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16224 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16225 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16226 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16227 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16228 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16230 digest
[0] -= SHA1M_A
;
16231 digest
[1] -= SHA1M_B
;
16232 digest
[2] -= SHA1M_C
;
16233 digest
[3] -= SHA1M_D
;
16234 digest
[4] -= SHA1M_E
;
16236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16238 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16240 salt
->salt_len
= salt_len
;
16242 return (PARSER_OK
);
16245 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16247 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16249 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16251 u32
*digest
= (u32
*) hash_buf
->digest
;
16253 salt_t
*salt
= hash_buf
->salt
;
16255 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16261 char *iter_pos
= input_buf
+ 14;
16263 const int iter
= atoi (iter_pos
);
16265 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16267 salt
->salt_iter
= iter
- 1;
16269 char *salt_pos
= strchr (iter_pos
, '$');
16271 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16275 char *hash_pos
= strchr (salt_pos
, '$');
16277 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16279 const uint salt_len
= hash_pos
- salt_pos
;
16283 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16285 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16287 salt
->salt_len
= salt_len
;
16289 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16290 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16292 // add some stuff to normal salt to make sorted happy
16294 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16295 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16296 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16297 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16298 salt
->salt_buf
[4] = salt
->salt_iter
;
16300 // base64 decode hash
16302 u8 tmp_buf
[100] = { 0 };
16304 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16306 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16308 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16310 memcpy (digest
, tmp_buf
, 32);
16312 digest
[0] = byte_swap_32 (digest
[0]);
16313 digest
[1] = byte_swap_32 (digest
[1]);
16314 digest
[2] = byte_swap_32 (digest
[2]);
16315 digest
[3] = byte_swap_32 (digest
[3]);
16316 digest
[4] = byte_swap_32 (digest
[4]);
16317 digest
[5] = byte_swap_32 (digest
[5]);
16318 digest
[6] = byte_swap_32 (digest
[6]);
16319 digest
[7] = byte_swap_32 (digest
[7]);
16321 return (PARSER_OK
);
16324 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16326 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16328 u32
*digest
= (u32
*) hash_buf
->digest
;
16330 salt_t
*salt
= hash_buf
->salt
;
16332 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16333 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16337 digest
[0] = byte_swap_32 (digest
[0]);
16338 digest
[1] = byte_swap_32 (digest
[1]);
16340 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16341 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16342 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16344 char iter_c
= input_buf
[17];
16345 char iter_d
= input_buf
[19];
16347 // atm only defaults, let's see if there's more request
16348 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16349 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16351 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16353 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16354 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16355 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16356 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16358 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16359 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16360 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16361 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16363 salt
->salt_len
= 16;
16365 return (PARSER_OK
);
16368 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16370 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16372 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16374 u32
*digest
= (u32
*) hash_buf
->digest
;
16376 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16378 salt_t
*salt
= hash_buf
->salt
;
16380 char *salt_pos
= input_buf
+ 10;
16382 char *hash_pos
= strchr (salt_pos
, '$');
16384 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16386 uint salt_len
= hash_pos
- salt_pos
;
16390 uint hash_len
= input_len
- 10 - salt_len
- 1;
16392 // base64 decode salt
16394 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16396 u8 tmp_buf
[100] = { 0 };
16398 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16400 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16402 tmp_buf
[salt_len
] = 0x80;
16404 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16406 salt
->salt_len
= salt_len
;
16408 // base64 decode hash
16410 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16412 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16414 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16416 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16418 uint user_len
= hash_len
- 32;
16420 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16422 user_len
--; // skip the trailing space
16424 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16425 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16426 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16427 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16429 digest
[0] = byte_swap_32 (digest
[0]);
16430 digest
[1] = byte_swap_32 (digest
[1]);
16431 digest
[2] = byte_swap_32 (digest
[2]);
16432 digest
[3] = byte_swap_32 (digest
[3]);
16434 // store username for host only (output hash if cracked)
16436 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16437 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16439 return (PARSER_OK
);
16442 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16444 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16446 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16448 u32
*digest
= (u32
*) hash_buf
->digest
;
16450 salt_t
*salt
= hash_buf
->salt
;
16452 char *iter_pos
= input_buf
+ 10;
16454 u32 iter
= atoi (iter_pos
);
16458 return (PARSER_SALT_ITERATION
);
16461 iter
--; // first iteration is special
16463 salt
->salt_iter
= iter
;
16465 char *base64_pos
= strchr (iter_pos
, '}');
16467 if (base64_pos
== NULL
)
16469 return (PARSER_SIGNATURE_UNMATCHED
);
16474 // base64 decode salt
16476 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16478 u8 tmp_buf
[100] = { 0 };
16480 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16482 if (decoded_len
< 24)
16484 return (PARSER_SALT_LENGTH
);
16489 uint salt_len
= decoded_len
- 20;
16491 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16492 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16494 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16496 salt
->salt_len
= salt_len
;
16500 u32
*digest_ptr
= (u32
*) tmp_buf
;
16502 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16503 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16504 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16505 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16506 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16508 return (PARSER_OK
);
16511 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16513 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16515 u32
*digest
= (u32
*) hash_buf
->digest
;
16517 salt_t
*salt
= hash_buf
->salt
;
16519 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16520 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16521 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16522 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16523 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16525 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16527 uint salt_len
= input_len
- 40 - 1;
16529 char *salt_buf
= input_buf
+ 40 + 1;
16531 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16533 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16535 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16537 salt
->salt_len
= salt_len
;
16539 return (PARSER_OK
);
16542 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16544 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16546 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16548 u32
*digest
= (u32
*) hash_buf
->digest
;
16550 salt_t
*salt
= hash_buf
->salt
;
16552 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16558 char *V_pos
= input_buf
+ 5;
16560 char *R_pos
= strchr (V_pos
, '*');
16562 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16564 u32 V_len
= R_pos
- V_pos
;
16568 char *bits_pos
= strchr (R_pos
, '*');
16570 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16572 u32 R_len
= bits_pos
- R_pos
;
16576 char *P_pos
= strchr (bits_pos
, '*');
16578 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16580 u32 bits_len
= P_pos
- bits_pos
;
16584 char *enc_md_pos
= strchr (P_pos
, '*');
16586 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16588 u32 P_len
= enc_md_pos
- P_pos
;
16592 char *id_len_pos
= strchr (enc_md_pos
, '*');
16594 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16596 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16600 char *id_buf_pos
= strchr (id_len_pos
, '*');
16602 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16604 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16608 char *u_len_pos
= strchr (id_buf_pos
, '*');
16610 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16612 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16614 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16618 char *u_buf_pos
= strchr (u_len_pos
, '*');
16620 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16622 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16626 char *o_len_pos
= strchr (u_buf_pos
, '*');
16628 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16630 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16632 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16636 char *o_buf_pos
= strchr (o_len_pos
, '*');
16638 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16640 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16644 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;
16646 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16650 const int V
= atoi (V_pos
);
16651 const int R
= atoi (R_pos
);
16652 const int P
= atoi (P_pos
);
16654 if (V
!= 1) return (PARSER_SALT_VALUE
);
16655 if (R
!= 2) return (PARSER_SALT_VALUE
);
16657 const int enc_md
= atoi (enc_md_pos
);
16659 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16661 const int id_len
= atoi (id_len_pos
);
16662 const int u_len
= atoi (u_len_pos
);
16663 const int o_len
= atoi (o_len_pos
);
16665 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16666 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16667 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16669 const int bits
= atoi (bits_pos
);
16671 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16673 // copy data to esalt
16679 pdf
->enc_md
= enc_md
;
16681 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16682 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16683 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16684 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16685 pdf
->id_len
= id_len
;
16687 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16688 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16689 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16690 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16691 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16692 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16693 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16694 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16695 pdf
->u_len
= u_len
;
16697 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16698 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16699 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16700 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16701 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16702 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16703 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16704 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16705 pdf
->o_len
= o_len
;
16707 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16708 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16709 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16710 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16712 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16713 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16714 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16715 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16716 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16717 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16718 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16719 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16721 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16722 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16723 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16724 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16725 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16726 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16727 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16728 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16730 // we use ID for salt, maybe needs to change, we will see...
16732 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16733 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16734 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16735 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16736 salt
->salt_len
= pdf
->id_len
;
16738 digest
[0] = pdf
->u_buf
[0];
16739 digest
[1] = pdf
->u_buf
[1];
16740 digest
[2] = pdf
->u_buf
[2];
16741 digest
[3] = pdf
->u_buf
[3];
16743 return (PARSER_OK
);
16746 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16748 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16751 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16753 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16755 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16757 u32
*digest
= (u32
*) hash_buf
->digest
;
16759 salt_t
*salt
= hash_buf
->salt
;
16761 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16767 char *V_pos
= input_buf
+ 5;
16769 char *R_pos
= strchr (V_pos
, '*');
16771 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16773 u32 V_len
= R_pos
- V_pos
;
16777 char *bits_pos
= strchr (R_pos
, '*');
16779 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16781 u32 R_len
= bits_pos
- R_pos
;
16785 char *P_pos
= strchr (bits_pos
, '*');
16787 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16789 u32 bits_len
= P_pos
- bits_pos
;
16793 char *enc_md_pos
= strchr (P_pos
, '*');
16795 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16797 u32 P_len
= enc_md_pos
- P_pos
;
16801 char *id_len_pos
= strchr (enc_md_pos
, '*');
16803 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16805 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16809 char *id_buf_pos
= strchr (id_len_pos
, '*');
16811 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16813 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16817 char *u_len_pos
= strchr (id_buf_pos
, '*');
16819 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16821 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16823 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16827 char *u_buf_pos
= strchr (u_len_pos
, '*');
16829 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16831 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16835 char *o_len_pos
= strchr (u_buf_pos
, '*');
16837 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16839 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16841 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16845 char *o_buf_pos
= strchr (o_len_pos
, '*');
16847 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16849 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16853 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16855 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16857 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16859 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16863 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;
16865 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16869 const int V
= atoi (V_pos
);
16870 const int R
= atoi (R_pos
);
16871 const int P
= atoi (P_pos
);
16873 if (V
!= 1) return (PARSER_SALT_VALUE
);
16874 if (R
!= 2) return (PARSER_SALT_VALUE
);
16876 const int enc_md
= atoi (enc_md_pos
);
16878 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16880 const int id_len
= atoi (id_len_pos
);
16881 const int u_len
= atoi (u_len_pos
);
16882 const int o_len
= atoi (o_len_pos
);
16884 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16885 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16886 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16888 const int bits
= atoi (bits_pos
);
16890 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16892 // copy data to esalt
16898 pdf
->enc_md
= enc_md
;
16900 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16901 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16902 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16903 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16904 pdf
->id_len
= id_len
;
16906 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16907 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16908 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16909 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16910 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16911 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16912 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16913 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16914 pdf
->u_len
= u_len
;
16916 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16917 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16918 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16919 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16920 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16921 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16922 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16923 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16924 pdf
->o_len
= o_len
;
16926 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16927 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16928 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16929 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16931 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16932 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16933 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16934 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16935 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16936 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16937 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16938 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16940 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16941 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16942 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16943 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16944 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16945 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16946 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16947 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16949 pdf
->rc4key
[1] = 0;
16950 pdf
->rc4key
[0] = 0;
16952 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16953 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16954 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16955 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16956 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16957 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16958 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16959 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16960 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16961 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16963 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16964 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16966 // we use ID for salt, maybe needs to change, we will see...
16968 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16969 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16970 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16971 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16972 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16973 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16974 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16975 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16976 salt
->salt_len
= pdf
->id_len
+ 16;
16978 digest
[0] = pdf
->rc4key
[0];
16979 digest
[1] = pdf
->rc4key
[1];
16983 return (PARSER_OK
);
16986 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16988 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16990 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16992 u32
*digest
= (u32
*) hash_buf
->digest
;
16994 salt_t
*salt
= hash_buf
->salt
;
16996 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17002 char *V_pos
= input_buf
+ 5;
17004 char *R_pos
= strchr (V_pos
, '*');
17006 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17008 u32 V_len
= R_pos
- V_pos
;
17012 char *bits_pos
= strchr (R_pos
, '*');
17014 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17016 u32 R_len
= bits_pos
- R_pos
;
17020 char *P_pos
= strchr (bits_pos
, '*');
17022 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17024 u32 bits_len
= P_pos
- bits_pos
;
17028 char *enc_md_pos
= strchr (P_pos
, '*');
17030 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17032 u32 P_len
= enc_md_pos
- P_pos
;
17036 char *id_len_pos
= strchr (enc_md_pos
, '*');
17038 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17040 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17044 char *id_buf_pos
= strchr (id_len_pos
, '*');
17046 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17048 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17052 char *u_len_pos
= strchr (id_buf_pos
, '*');
17054 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17056 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17058 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17062 char *u_buf_pos
= strchr (u_len_pos
, '*');
17064 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17066 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17070 char *o_len_pos
= strchr (u_buf_pos
, '*');
17072 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17074 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17076 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17080 char *o_buf_pos
= strchr (o_len_pos
, '*');
17082 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17084 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17088 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;
17090 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17094 const int V
= atoi (V_pos
);
17095 const int R
= atoi (R_pos
);
17096 const int P
= atoi (P_pos
);
17100 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17101 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17103 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17105 const int id_len
= atoi (id_len_pos
);
17106 const int u_len
= atoi (u_len_pos
);
17107 const int o_len
= atoi (o_len_pos
);
17109 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17111 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17112 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17114 const int bits
= atoi (bits_pos
);
17116 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17122 enc_md
= atoi (enc_md_pos
);
17125 // copy data to esalt
17131 pdf
->enc_md
= enc_md
;
17133 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17134 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17135 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17136 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17140 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17141 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17142 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17143 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17146 pdf
->id_len
= id_len
;
17148 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17149 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17150 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17151 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17152 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17153 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17154 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17155 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17156 pdf
->u_len
= u_len
;
17158 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17159 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17160 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17161 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17162 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17163 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17164 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17165 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17166 pdf
->o_len
= o_len
;
17168 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17169 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17170 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17171 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17175 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17176 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17177 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17178 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17181 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17182 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17183 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17184 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17185 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17186 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17187 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17188 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17190 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17191 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17192 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17193 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17194 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17195 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17196 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17197 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17199 // precompute rc4 data for later use
17215 uint salt_pc_block
[32] = { 0 };
17217 char *salt_pc_ptr
= (char *) salt_pc_block
;
17219 memcpy (salt_pc_ptr
, padding
, 32);
17220 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17222 uint salt_pc_digest
[4] = { 0 };
17224 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17226 pdf
->rc4data
[0] = salt_pc_digest
[0];
17227 pdf
->rc4data
[1] = salt_pc_digest
[1];
17229 // we use ID for salt, maybe needs to change, we will see...
17231 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17232 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17233 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17234 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17235 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17236 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17237 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17238 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17239 salt
->salt_len
= pdf
->id_len
+ 16;
17241 salt
->salt_iter
= ROUNDS_PDF14
;
17243 digest
[0] = pdf
->u_buf
[0];
17244 digest
[1] = pdf
->u_buf
[1];
17248 return (PARSER_OK
);
17251 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17253 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17255 if (ret
!= PARSER_OK
)
17260 u32
*digest
= (u32
*) hash_buf
->digest
;
17262 salt_t
*salt
= hash_buf
->salt
;
17264 digest
[0] -= SHA256M_A
;
17265 digest
[1] -= SHA256M_B
;
17266 digest
[2] -= SHA256M_C
;
17267 digest
[3] -= SHA256M_D
;
17268 digest
[4] -= SHA256M_E
;
17269 digest
[5] -= SHA256M_F
;
17270 digest
[6] -= SHA256M_G
;
17271 digest
[7] -= SHA256M_H
;
17273 salt
->salt_buf
[2] = 0x80;
17275 return (PARSER_OK
);
17278 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17280 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17282 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17284 u32
*digest
= (u32
*) hash_buf
->digest
;
17286 salt_t
*salt
= hash_buf
->salt
;
17288 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17294 char *V_pos
= input_buf
+ 5;
17296 char *R_pos
= strchr (V_pos
, '*');
17298 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 u32 V_len
= R_pos
- V_pos
;
17304 char *bits_pos
= strchr (R_pos
, '*');
17306 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 u32 R_len
= bits_pos
- R_pos
;
17312 char *P_pos
= strchr (bits_pos
, '*');
17314 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17316 u32 bits_len
= P_pos
- bits_pos
;
17320 char *enc_md_pos
= strchr (P_pos
, '*');
17322 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17324 u32 P_len
= enc_md_pos
- P_pos
;
17328 char *id_len_pos
= strchr (enc_md_pos
, '*');
17330 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17332 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17336 char *id_buf_pos
= strchr (id_len_pos
, '*');
17338 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17340 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17344 char *u_len_pos
= strchr (id_buf_pos
, '*');
17346 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17348 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17352 char *u_buf_pos
= strchr (u_len_pos
, '*');
17354 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17360 char *o_len_pos
= strchr (u_buf_pos
, '*');
17362 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17364 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17368 char *o_buf_pos
= strchr (o_len_pos
, '*');
17370 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17372 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17376 char *last
= strchr (o_buf_pos
, '*');
17378 if (last
== NULL
) last
= input_buf
+ input_len
;
17380 u32 o_buf_len
= last
- o_buf_pos
;
17384 const int V
= atoi (V_pos
);
17385 const int R
= atoi (R_pos
);
17389 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17390 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17392 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17394 const int bits
= atoi (bits_pos
);
17396 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17398 int enc_md
= atoi (enc_md_pos
);
17400 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17402 const uint id_len
= atoi (id_len_pos
);
17403 const uint u_len
= atoi (u_len_pos
);
17404 const uint o_len
= atoi (o_len_pos
);
17406 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17407 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17408 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17409 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17410 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17411 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17412 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17413 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17415 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17416 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17417 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17419 // copy data to esalt
17421 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17423 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17425 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17428 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17429 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17431 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17432 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17434 salt
->salt_len
= 8;
17435 salt
->salt_iter
= ROUNDS_PDF17L8
;
17437 digest
[0] = pdf
->u_buf
[0];
17438 digest
[1] = pdf
->u_buf
[1];
17439 digest
[2] = pdf
->u_buf
[2];
17440 digest
[3] = pdf
->u_buf
[3];
17441 digest
[4] = pdf
->u_buf
[4];
17442 digest
[5] = pdf
->u_buf
[5];
17443 digest
[6] = pdf
->u_buf
[6];
17444 digest
[7] = pdf
->u_buf
[7];
17446 return (PARSER_OK
);
17449 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17451 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17453 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17455 u32
*digest
= (u32
*) hash_buf
->digest
;
17457 salt_t
*salt
= hash_buf
->salt
;
17459 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17467 char *iter_pos
= input_buf
+ 7;
17469 u32 iter
= atoi (iter_pos
);
17471 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17472 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17474 // first is *raw* salt
17476 char *salt_pos
= strchr (iter_pos
, ':');
17478 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17482 char *hash_pos
= strchr (salt_pos
, ':');
17484 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17486 u32 salt_len
= hash_pos
- salt_pos
;
17488 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17492 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17494 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17498 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17500 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17502 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17504 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17505 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17507 salt
->salt_len
= salt_len
;
17508 salt
->salt_iter
= iter
- 1;
17512 u8 tmp_buf
[100] = { 0 };
17514 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17516 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17518 memcpy (digest
, tmp_buf
, 16);
17520 digest
[0] = byte_swap_32 (digest
[0]);
17521 digest
[1] = byte_swap_32 (digest
[1]);
17522 digest
[2] = byte_swap_32 (digest
[2]);
17523 digest
[3] = byte_swap_32 (digest
[3]);
17525 // add some stuff to normal salt to make sorted happy
17527 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17528 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17529 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17530 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17531 salt
->salt_buf
[4] = salt
->salt_iter
;
17533 return (PARSER_OK
);
17536 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17538 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17540 u32
*digest
= (u32
*) hash_buf
->digest
;
17542 salt_t
*salt
= hash_buf
->salt
;
17544 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17545 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17546 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17547 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17549 digest
[0] = byte_swap_32 (digest
[0]);
17550 digest
[1] = byte_swap_32 (digest
[1]);
17551 digest
[2] = byte_swap_32 (digest
[2]);
17552 digest
[3] = byte_swap_32 (digest
[3]);
17554 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17556 uint salt_len
= input_len
- 32 - 1;
17558 char *salt_buf
= input_buf
+ 32 + 1;
17560 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17562 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17564 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17566 salt
->salt_len
= salt_len
;
17568 return (PARSER_OK
);
17571 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17573 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17575 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17577 u32
*digest
= (u32
*) hash_buf
->digest
;
17579 salt_t
*salt
= hash_buf
->salt
;
17581 char *user_pos
= input_buf
+ 10;
17583 char *salt_pos
= strchr (user_pos
, '*');
17585 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17589 char *hash_pos
= strchr (salt_pos
, '*');
17593 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17595 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17597 uint user_len
= salt_pos
- user_pos
- 1;
17599 uint salt_len
= hash_pos
- salt_pos
- 1;
17601 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17607 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17608 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17609 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17610 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17612 digest
[0] = byte_swap_32 (digest
[0]);
17613 digest
[1] = byte_swap_32 (digest
[1]);
17614 digest
[2] = byte_swap_32 (digest
[2]);
17615 digest
[3] = byte_swap_32 (digest
[3]);
17617 digest
[0] -= MD5M_A
;
17618 digest
[1] -= MD5M_B
;
17619 digest
[2] -= MD5M_C
;
17620 digest
[3] -= MD5M_D
;
17626 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17628 // first 4 bytes are the "challenge"
17630 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17631 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17632 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17633 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17635 // append the user name
17637 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17639 salt
->salt_len
= 4 + user_len
;
17641 return (PARSER_OK
);
17644 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17646 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17648 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17650 u32
*digest
= (u32
*) hash_buf
->digest
;
17652 salt_t
*salt
= hash_buf
->salt
;
17654 char *salt_pos
= input_buf
+ 9;
17656 char *hash_pos
= strchr (salt_pos
, '*');
17658 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17662 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17664 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17666 uint salt_len
= hash_pos
- salt_pos
- 1;
17668 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17674 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17675 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17676 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17677 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17678 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17686 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17688 salt
->salt_len
= salt_len
;
17690 return (PARSER_OK
);
17693 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17695 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17697 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17699 u32
*digest
= (u32
*) hash_buf
->digest
;
17701 salt_t
*salt
= hash_buf
->salt
;
17703 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17709 char *cry_master_len_pos
= input_buf
+ 9;
17711 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17713 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17715 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17717 cry_master_buf_pos
++;
17719 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17721 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17723 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17725 cry_salt_len_pos
++;
17727 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17729 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17731 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17733 cry_salt_buf_pos
++;
17735 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17737 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17739 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17743 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17745 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17747 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17751 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17753 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17755 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17759 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17761 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17763 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17765 public_key_len_pos
++;
17767 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17769 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17771 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17773 public_key_buf_pos
++;
17775 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;
17777 const uint cry_master_len
= atoi (cry_master_len_pos
);
17778 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17779 const uint ckey_len
= atoi (ckey_len_pos
);
17780 const uint public_key_len
= atoi (public_key_len_pos
);
17782 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17783 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17784 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17785 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17787 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17789 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17791 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17794 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17796 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17798 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17801 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17803 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17805 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17808 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17809 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17810 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17813 * store digest (should be unique enought, hopefully)
17816 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17817 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17818 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17819 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17825 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17827 const uint cry_rounds
= atoi (cry_rounds_pos
);
17829 salt
->salt_iter
= cry_rounds
- 1;
17831 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17833 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17835 salt
->salt_len
= salt_len
;
17837 return (PARSER_OK
);
17840 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17842 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17844 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17846 u32
*digest
= (u32
*) hash_buf
->digest
;
17848 salt_t
*salt
= hash_buf
->salt
;
17850 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17852 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17854 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17856 memcpy (temp_input_buf
, input_buf
, input_len
);
17860 char *URI_server_pos
= temp_input_buf
+ 6;
17862 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17864 if (URI_client_pos
== NULL
)
17866 myfree (temp_input_buf
);
17868 return (PARSER_SEPARATOR_UNMATCHED
);
17871 URI_client_pos
[0] = 0;
17874 uint URI_server_len
= strlen (URI_server_pos
);
17876 if (URI_server_len
> 512)
17878 myfree (temp_input_buf
);
17880 return (PARSER_SALT_LENGTH
);
17885 char *user_pos
= strchr (URI_client_pos
, '*');
17887 if (user_pos
== NULL
)
17889 myfree (temp_input_buf
);
17891 return (PARSER_SEPARATOR_UNMATCHED
);
17897 uint URI_client_len
= strlen (URI_client_pos
);
17899 if (URI_client_len
> 512)
17901 myfree (temp_input_buf
);
17903 return (PARSER_SALT_LENGTH
);
17908 char *realm_pos
= strchr (user_pos
, '*');
17910 if (realm_pos
== NULL
)
17912 myfree (temp_input_buf
);
17914 return (PARSER_SEPARATOR_UNMATCHED
);
17920 uint user_len
= strlen (user_pos
);
17922 if (user_len
> 116)
17924 myfree (temp_input_buf
);
17926 return (PARSER_SALT_LENGTH
);
17931 char *method_pos
= strchr (realm_pos
, '*');
17933 if (method_pos
== NULL
)
17935 myfree (temp_input_buf
);
17937 return (PARSER_SEPARATOR_UNMATCHED
);
17943 uint realm_len
= strlen (realm_pos
);
17945 if (realm_len
> 116)
17947 myfree (temp_input_buf
);
17949 return (PARSER_SALT_LENGTH
);
17954 char *URI_prefix_pos
= strchr (method_pos
, '*');
17956 if (URI_prefix_pos
== NULL
)
17958 myfree (temp_input_buf
);
17960 return (PARSER_SEPARATOR_UNMATCHED
);
17963 URI_prefix_pos
[0] = 0;
17966 uint method_len
= strlen (method_pos
);
17968 if (method_len
> 246)
17970 myfree (temp_input_buf
);
17972 return (PARSER_SALT_LENGTH
);
17977 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17979 if (URI_resource_pos
== NULL
)
17981 myfree (temp_input_buf
);
17983 return (PARSER_SEPARATOR_UNMATCHED
);
17986 URI_resource_pos
[0] = 0;
17987 URI_resource_pos
++;
17989 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17991 if (URI_prefix_len
> 245)
17993 myfree (temp_input_buf
);
17995 return (PARSER_SALT_LENGTH
);
18000 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18002 if (URI_suffix_pos
== NULL
)
18004 myfree (temp_input_buf
);
18006 return (PARSER_SEPARATOR_UNMATCHED
);
18009 URI_suffix_pos
[0] = 0;
18012 uint URI_resource_len
= strlen (URI_resource_pos
);
18014 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18016 myfree (temp_input_buf
);
18018 return (PARSER_SALT_LENGTH
);
18023 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18025 if (nonce_pos
== NULL
)
18027 myfree (temp_input_buf
);
18029 return (PARSER_SEPARATOR_UNMATCHED
);
18035 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18037 if (URI_suffix_len
> 245)
18039 myfree (temp_input_buf
);
18041 return (PARSER_SALT_LENGTH
);
18046 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18048 if (nonce_client_pos
== NULL
)
18050 myfree (temp_input_buf
);
18052 return (PARSER_SEPARATOR_UNMATCHED
);
18055 nonce_client_pos
[0] = 0;
18056 nonce_client_pos
++;
18058 uint nonce_len
= strlen (nonce_pos
);
18060 if (nonce_len
< 1 || nonce_len
> 50)
18062 myfree (temp_input_buf
);
18064 return (PARSER_SALT_LENGTH
);
18069 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18071 if (nonce_count_pos
== NULL
)
18073 myfree (temp_input_buf
);
18075 return (PARSER_SEPARATOR_UNMATCHED
);
18078 nonce_count_pos
[0] = 0;
18081 uint nonce_client_len
= strlen (nonce_client_pos
);
18083 if (nonce_client_len
> 50)
18085 myfree (temp_input_buf
);
18087 return (PARSER_SALT_LENGTH
);
18092 char *qop_pos
= strchr (nonce_count_pos
, '*');
18094 if (qop_pos
== NULL
)
18096 myfree (temp_input_buf
);
18098 return (PARSER_SEPARATOR_UNMATCHED
);
18104 uint nonce_count_len
= strlen (nonce_count_pos
);
18106 if (nonce_count_len
> 50)
18108 myfree (temp_input_buf
);
18110 return (PARSER_SALT_LENGTH
);
18115 char *directive_pos
= strchr (qop_pos
, '*');
18117 if (directive_pos
== NULL
)
18119 myfree (temp_input_buf
);
18121 return (PARSER_SEPARATOR_UNMATCHED
);
18124 directive_pos
[0] = 0;
18127 uint qop_len
= strlen (qop_pos
);
18131 myfree (temp_input_buf
);
18133 return (PARSER_SALT_LENGTH
);
18138 char *digest_pos
= strchr (directive_pos
, '*');
18140 if (digest_pos
== NULL
)
18142 myfree (temp_input_buf
);
18144 return (PARSER_SEPARATOR_UNMATCHED
);
18150 uint directive_len
= strlen (directive_pos
);
18152 if (directive_len
!= 3)
18154 myfree (temp_input_buf
);
18156 return (PARSER_SALT_LENGTH
);
18159 if (memcmp (directive_pos
, "MD5", 3))
18161 log_info ("ERROR: only the MD5 directive is currently supported\n");
18163 myfree (temp_input_buf
);
18165 return (PARSER_SIP_AUTH_DIRECTIVE
);
18169 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18174 uint md5_max_len
= 4 * 64;
18176 uint md5_remaining_len
= md5_max_len
;
18178 uint tmp_md5_buf
[64] = { 0 };
18180 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18182 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18184 md5_len
+= method_len
+ 1;
18185 tmp_md5_ptr
+= method_len
+ 1;
18187 if (URI_prefix_len
> 0)
18189 md5_remaining_len
= md5_max_len
- md5_len
;
18191 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18193 md5_len
+= URI_prefix_len
+ 1;
18194 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18197 md5_remaining_len
= md5_max_len
- md5_len
;
18199 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18201 md5_len
+= URI_resource_len
;
18202 tmp_md5_ptr
+= URI_resource_len
;
18204 if (URI_suffix_len
> 0)
18206 md5_remaining_len
= md5_max_len
- md5_len
;
18208 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18210 md5_len
+= 1 + URI_suffix_len
;
18213 uint tmp_digest
[4] = { 0 };
18215 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18217 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18218 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18219 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18220 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18226 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18228 uint esalt_len
= 0;
18230 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18232 // there are 2 possibilities for the esalt:
18234 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18236 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18238 if (esalt_len
> max_esalt_len
)
18240 myfree (temp_input_buf
);
18242 return (PARSER_SALT_LENGTH
);
18245 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18257 esalt_len
= 1 + nonce_len
+ 1 + 32;
18259 if (esalt_len
> max_esalt_len
)
18261 myfree (temp_input_buf
);
18263 return (PARSER_SALT_LENGTH
);
18266 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18274 // add 0x80 to esalt
18276 esalt_buf_ptr
[esalt_len
] = 0x80;
18278 sip
->esalt_len
= esalt_len
;
18284 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18286 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18288 uint max_salt_len
= 119;
18290 if (salt_len
> max_salt_len
)
18292 myfree (temp_input_buf
);
18294 return (PARSER_SALT_LENGTH
);
18297 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18299 sip
->salt_len
= salt_len
;
18302 * fake salt (for sorting)
18305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18309 uint fake_salt_len
= salt_len
;
18311 if (fake_salt_len
> max_salt_len
)
18313 fake_salt_len
= max_salt_len
;
18316 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18318 salt
->salt_len
= fake_salt_len
;
18324 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18325 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18326 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18327 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18329 digest
[0] = byte_swap_32 (digest
[0]);
18330 digest
[1] = byte_swap_32 (digest
[1]);
18331 digest
[2] = byte_swap_32 (digest
[2]);
18332 digest
[3] = byte_swap_32 (digest
[3]);
18334 myfree (temp_input_buf
);
18336 return (PARSER_OK
);
18339 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18341 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18343 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18345 u32
*digest
= (u32
*) hash_buf
->digest
;
18347 salt_t
*salt
= hash_buf
->salt
;
18351 char *digest_pos
= input_buf
;
18353 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18360 char *salt_buf
= input_buf
+ 8 + 1;
18364 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18366 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18368 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18370 salt
->salt_len
= salt_len
;
18372 return (PARSER_OK
);
18375 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18377 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18379 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18381 u32
*digest
= (u32
*) hash_buf
->digest
;
18383 salt_t
*salt
= hash_buf
->salt
;
18385 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18391 char *p_buf_pos
= input_buf
+ 4;
18393 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18395 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18397 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18399 NumCyclesPower_pos
++;
18401 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18403 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18405 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18409 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18411 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18413 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18417 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18419 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18421 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18425 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18427 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18429 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18433 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18435 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18437 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18441 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18443 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18445 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18449 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18451 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18453 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18457 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18459 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18461 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18465 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;
18467 const uint iter
= atoi (NumCyclesPower_pos
);
18468 const uint crc
= atoi (crc_buf_pos
);
18469 const uint p_buf
= atoi (p_buf_pos
);
18470 const uint salt_len
= atoi (salt_len_pos
);
18471 const uint iv_len
= atoi (iv_len_pos
);
18472 const uint unpack_size
= atoi (unpack_size_pos
);
18473 const uint data_len
= atoi (data_len_pos
);
18479 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18480 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18482 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18484 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18486 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18492 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18493 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18494 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18495 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18497 seven_zip
->iv_len
= iv_len
;
18499 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18501 seven_zip
->salt_len
= 0;
18503 seven_zip
->crc
= crc
;
18505 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18507 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18509 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18512 seven_zip
->data_len
= data_len
;
18514 seven_zip
->unpack_size
= unpack_size
;
18518 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18519 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18520 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18521 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18523 salt
->salt_len
= 16;
18525 salt
->salt_sign
[0] = iter
;
18527 salt
->salt_iter
= 1 << iter
;
18538 return (PARSER_OK
);
18541 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18543 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18545 u32
*digest
= (u32
*) hash_buf
->digest
;
18547 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18548 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18549 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18550 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18551 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18552 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18553 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18554 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18556 digest
[0] = byte_swap_32 (digest
[0]);
18557 digest
[1] = byte_swap_32 (digest
[1]);
18558 digest
[2] = byte_swap_32 (digest
[2]);
18559 digest
[3] = byte_swap_32 (digest
[3]);
18560 digest
[4] = byte_swap_32 (digest
[4]);
18561 digest
[5] = byte_swap_32 (digest
[5]);
18562 digest
[6] = byte_swap_32 (digest
[6]);
18563 digest
[7] = byte_swap_32 (digest
[7]);
18565 return (PARSER_OK
);
18568 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18570 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18572 u32
*digest
= (u32
*) hash_buf
->digest
;
18574 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18575 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18576 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18577 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18578 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18579 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18580 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18581 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18582 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18583 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18584 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18585 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18586 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18587 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18588 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18589 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18591 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18592 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18593 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18594 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18595 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18596 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18597 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18598 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18599 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18600 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18601 digest
[10] = byte_swap_32 (digest
[10]);
18602 digest
[11] = byte_swap_32 (digest
[11]);
18603 digest
[12] = byte_swap_32 (digest
[12]);
18604 digest
[13] = byte_swap_32 (digest
[13]);
18605 digest
[14] = byte_swap_32 (digest
[14]);
18606 digest
[15] = byte_swap_32 (digest
[15]);
18608 return (PARSER_OK
);
18611 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18613 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18615 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18617 u32
*digest
= (u32
*) hash_buf
->digest
;
18619 salt_t
*salt
= hash_buf
->salt
;
18621 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18629 char *iter_pos
= input_buf
+ 4;
18631 u32 iter
= atoi (iter_pos
);
18633 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18634 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18636 // first is *raw* salt
18638 char *salt_pos
= strchr (iter_pos
, ':');
18640 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18644 char *hash_pos
= strchr (salt_pos
, ':');
18646 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18648 u32 salt_len
= hash_pos
- salt_pos
;
18650 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18654 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18656 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18660 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18662 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18664 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18666 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18667 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18669 salt
->salt_len
= salt_len
;
18670 salt
->salt_iter
= iter
- 1;
18674 u8 tmp_buf
[100] = { 0 };
18676 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18678 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18680 memcpy (digest
, tmp_buf
, 16);
18682 // add some stuff to normal salt to make sorted happy
18684 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18685 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18686 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18687 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18688 salt
->salt_buf
[4] = salt
->salt_iter
;
18690 return (PARSER_OK
);
18693 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18695 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18697 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18699 u32
*digest
= (u32
*) hash_buf
->digest
;
18701 salt_t
*salt
= hash_buf
->salt
;
18703 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18711 char *iter_pos
= input_buf
+ 5;
18713 u32 iter
= atoi (iter_pos
);
18715 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18716 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18718 // first is *raw* salt
18720 char *salt_pos
= strchr (iter_pos
, ':');
18722 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18726 char *hash_pos
= strchr (salt_pos
, ':');
18728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18730 u32 salt_len
= hash_pos
- salt_pos
;
18732 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18736 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18738 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18742 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18744 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18748 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18749 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18751 salt
->salt_len
= salt_len
;
18752 salt
->salt_iter
= iter
- 1;
18756 u8 tmp_buf
[100] = { 0 };
18758 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18760 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18762 memcpy (digest
, tmp_buf
, 16);
18764 digest
[0] = byte_swap_32 (digest
[0]);
18765 digest
[1] = byte_swap_32 (digest
[1]);
18766 digest
[2] = byte_swap_32 (digest
[2]);
18767 digest
[3] = byte_swap_32 (digest
[3]);
18769 // add some stuff to normal salt to make sorted happy
18771 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18772 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18773 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18774 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18775 salt
->salt_buf
[4] = salt
->salt_iter
;
18777 return (PARSER_OK
);
18780 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18782 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18784 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18786 u64
*digest
= (u64
*) hash_buf
->digest
;
18788 salt_t
*salt
= hash_buf
->salt
;
18790 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18798 char *iter_pos
= input_buf
+ 7;
18800 u32 iter
= atoi (iter_pos
);
18802 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18803 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18805 // first is *raw* salt
18807 char *salt_pos
= strchr (iter_pos
, ':');
18809 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18813 char *hash_pos
= strchr (salt_pos
, ':');
18815 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18817 u32 salt_len
= hash_pos
- salt_pos
;
18819 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18823 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18825 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18829 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18831 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18833 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18835 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18836 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18838 salt
->salt_len
= salt_len
;
18839 salt
->salt_iter
= iter
- 1;
18843 u8 tmp_buf
[100] = { 0 };
18845 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18847 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18849 memcpy (digest
, tmp_buf
, 64);
18851 digest
[0] = byte_swap_64 (digest
[0]);
18852 digest
[1] = byte_swap_64 (digest
[1]);
18853 digest
[2] = byte_swap_64 (digest
[2]);
18854 digest
[3] = byte_swap_64 (digest
[3]);
18855 digest
[4] = byte_swap_64 (digest
[4]);
18856 digest
[5] = byte_swap_64 (digest
[5]);
18857 digest
[6] = byte_swap_64 (digest
[6]);
18858 digest
[7] = byte_swap_64 (digest
[7]);
18860 // add some stuff to normal salt to make sorted happy
18862 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18863 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18864 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18865 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18866 salt
->salt_buf
[4] = salt
->salt_iter
;
18868 return (PARSER_OK
);
18871 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18873 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18875 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18877 uint
*digest
= (uint
*) hash_buf
->digest
;
18879 salt_t
*salt
= hash_buf
->salt
;
18885 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18887 char *hash_pos
= strchr (salt_pos
, '$');
18889 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18891 u32 salt_len
= hash_pos
- salt_pos
;
18893 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18897 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18899 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18903 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18904 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18922 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18923 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18925 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18926 salt
->salt_len
= 8;
18928 return (PARSER_OK
);
18931 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18933 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18935 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18937 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18939 if (c19
& 3) return (PARSER_HASH_VALUE
);
18941 salt_t
*salt
= hash_buf
->salt
;
18943 u32
*digest
= (u32
*) hash_buf
->digest
;
18947 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18948 | itoa64_to_int (input_buf
[2]) << 6
18949 | itoa64_to_int (input_buf
[3]) << 12
18950 | itoa64_to_int (input_buf
[4]) << 18;
18954 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18955 | itoa64_to_int (input_buf
[6]) << 6
18956 | itoa64_to_int (input_buf
[7]) << 12
18957 | itoa64_to_int (input_buf
[8]) << 18;
18959 salt
->salt_len
= 4;
18961 u8 tmp_buf
[100] = { 0 };
18963 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18965 memcpy (digest
, tmp_buf
, 8);
18969 IP (digest
[0], digest
[1], tt
);
18971 digest
[0] = rotr32 (digest
[0], 31);
18972 digest
[1] = rotr32 (digest
[1], 31);
18976 return (PARSER_OK
);
18979 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18981 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18983 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18985 u32
*digest
= (u32
*) hash_buf
->digest
;
18987 salt_t
*salt
= hash_buf
->salt
;
18993 char *type_pos
= input_buf
+ 6 + 1;
18995 char *salt_pos
= strchr (type_pos
, '*');
18997 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18999 u32 type_len
= salt_pos
- type_pos
;
19001 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19005 char *crypted_pos
= strchr (salt_pos
, '*');
19007 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19009 u32 salt_len
= crypted_pos
- salt_pos
;
19011 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19015 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19017 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19023 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19024 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19026 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19027 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19029 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19030 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19031 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19032 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19034 salt
->salt_len
= 24;
19035 salt
->salt_iter
= ROUNDS_RAR3
;
19037 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19038 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19040 digest
[0] = 0xc43d7b00;
19041 digest
[1] = 0x40070000;
19045 return (PARSER_OK
);
19048 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19050 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19052 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19054 u32
*digest
= (u32
*) hash_buf
->digest
;
19056 salt_t
*salt
= hash_buf
->salt
;
19058 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19064 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19066 char *param1_pos
= strchr (param0_pos
, '$');
19068 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19070 u32 param0_len
= param1_pos
- param0_pos
;
19074 char *param2_pos
= strchr (param1_pos
, '$');
19076 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19078 u32 param1_len
= param2_pos
- param1_pos
;
19082 char *param3_pos
= strchr (param2_pos
, '$');
19084 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19086 u32 param2_len
= param3_pos
- param2_pos
;
19090 char *param4_pos
= strchr (param3_pos
, '$');
19092 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19094 u32 param3_len
= param4_pos
- param3_pos
;
19098 char *param5_pos
= strchr (param4_pos
, '$');
19100 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19102 u32 param4_len
= param5_pos
- param4_pos
;
19106 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19108 char *salt_buf
= param1_pos
;
19109 char *iv
= param3_pos
;
19110 char *pswcheck
= param5_pos
;
19112 const uint salt_len
= atoi (param0_pos
);
19113 const uint iterations
= atoi (param2_pos
);
19114 const uint pswcheck_len
= atoi (param4_pos
);
19120 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19121 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19122 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19124 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19125 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19126 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19132 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19133 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19134 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19135 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19137 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19138 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19139 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19140 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19142 salt
->salt_len
= 16;
19144 salt
->salt_sign
[0] = iterations
;
19146 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19152 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19153 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19157 return (PARSER_OK
);
19160 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19162 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19164 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19166 u32
*digest
= (u32
*) hash_buf
->digest
;
19168 salt_t
*salt
= hash_buf
->salt
;
19170 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19177 char *account_pos
= input_buf
+ 11 + 1;
19183 if (account_pos
[0] == '*')
19187 data_pos
= strchr (account_pos
, '*');
19192 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19194 uint account_len
= data_pos
- account_pos
+ 1;
19196 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19201 data_len
= input_len
- 11 - 1 - account_len
- 2;
19203 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19207 /* assume $krb5tgs$23$checksum$edata2 */
19208 data_pos
= account_pos
;
19210 memcpy (krb5tgs
->account_info
, "**", 3);
19212 data_len
= input_len
- 11 - 1 - 1;
19215 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19217 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19219 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19221 const char p0
= data_pos
[i
+ 0];
19222 const char p1
= data_pos
[i
+ 1];
19224 *checksum_ptr
++ = hex_convert (p1
) << 0
19225 | hex_convert (p0
) << 4;
19228 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19230 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19233 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19235 const char p0
= data_pos
[i
+ 0];
19236 const char p1
= data_pos
[i
+ 1];
19237 *edata_ptr
++ = hex_convert (p1
) << 0
19238 | hex_convert (p0
) << 4;
19241 /* this is needed for hmac_md5 */
19242 *edata_ptr
++ = 0x80;
19244 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19245 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19246 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19247 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19249 salt
->salt_len
= 32;
19251 digest
[0] = krb5tgs
->checksum
[0];
19252 digest
[1] = krb5tgs
->checksum
[1];
19253 digest
[2] = krb5tgs
->checksum
[2];
19254 digest
[3] = krb5tgs
->checksum
[3];
19256 return (PARSER_OK
);
19259 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19261 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19263 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19265 u32
*digest
= (u32
*) hash_buf
->digest
;
19267 salt_t
*salt
= hash_buf
->salt
;
19274 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19278 char *wrapped_key_pos
;
19282 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19284 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19286 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19288 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19293 data_pos
= salt_pos
;
19295 wrapped_key_pos
= strchr (salt_pos
, '*');
19297 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19299 uint salt_len
= wrapped_key_pos
- salt_pos
;
19301 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19306 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19308 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19310 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19311 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19312 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19313 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19317 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19318 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19319 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19320 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19321 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19322 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19324 salt
->salt_len
= 40;
19326 digest
[0] = salt
->salt_buf
[0];
19327 digest
[1] = salt
->salt_buf
[1];
19328 digest
[2] = salt
->salt_buf
[2];
19329 digest
[3] = salt
->salt_buf
[3];
19331 return (PARSER_OK
);
19334 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19336 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19338 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19340 u32
*digest
= (u32
*) hash_buf
->digest
;
19342 salt_t
*salt
= hash_buf
->salt
;
19344 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19354 char *algorithm_pos
;
19356 char *final_random_seed_pos
;
19357 u32 final_random_seed_len
;
19359 char *transf_random_seed_pos
;
19360 u32 transf_random_seed_len
;
19365 /* default is no keyfile provided */
19366 char *keyfile_len_pos
;
19367 u32 keyfile_len
= 0;
19368 u32 is_keyfile_present
= 0;
19369 char *keyfile_inline_pos
;
19372 /* specific to version 1 */
19373 char *contents_len_pos
;
19375 char *contents_pos
;
19377 /* specific to version 2 */
19378 char *expected_bytes_pos
;
19379 u32 expected_bytes_len
;
19381 char *contents_hash_pos
;
19382 u32 contents_hash_len
;
19384 version_pos
= input_buf
+ 8 + 1 + 1;
19386 keepass
->version
= atoi (version_pos
);
19388 rounds_pos
= strchr (version_pos
, '*');
19390 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19394 salt
->salt_iter
= (atoi (rounds_pos
));
19396 algorithm_pos
= strchr (rounds_pos
, '*');
19398 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19402 keepass
->algorithm
= atoi (algorithm_pos
);
19404 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19406 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19408 final_random_seed_pos
++;
19410 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19411 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19412 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19413 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19415 if (keepass
->version
== 2)
19417 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19418 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19419 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19420 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19423 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19425 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19427 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19429 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19430 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19432 transf_random_seed_pos
++;
19434 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19435 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19436 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19437 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19438 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19439 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19440 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19441 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19443 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19445 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19447 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19449 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19453 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19454 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19455 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19456 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19458 if (keepass
->version
== 1)
19460 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19462 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19464 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19466 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19468 contents_hash_pos
++;
19470 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19471 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19472 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19473 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19474 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19475 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19476 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19477 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19479 /* get length of contents following */
19480 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19482 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19484 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19486 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19490 u32 inline_flag
= atoi (inline_flag_pos
);
19492 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19494 contents_len_pos
= strchr (inline_flag_pos
, '*');
19496 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19498 contents_len_pos
++;
19500 contents_len
= atoi (contents_len_pos
);
19502 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19504 contents_pos
= strchr (contents_len_pos
, '*');
19506 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19512 keepass
->contents_len
= contents_len
;
19514 contents_len
= contents_len
/ 4;
19516 keyfile_inline_pos
= strchr (contents_pos
, '*');
19518 u32 real_contents_len
;
19520 if (keyfile_inline_pos
== NULL
)
19521 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19524 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19525 keyfile_inline_pos
++;
19526 is_keyfile_present
= 1;
19529 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19531 for (i
= 0; i
< contents_len
; i
++)
19532 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19534 else if (keepass
->version
== 2)
19536 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19538 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19540 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19542 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19544 expected_bytes_pos
++;
19546 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19547 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19548 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19549 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19550 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19551 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19552 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19553 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19555 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19557 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19559 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19561 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19563 contents_hash_pos
++;
19565 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19566 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19567 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19568 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19569 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19570 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19571 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19572 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19574 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19576 if (keyfile_inline_pos
== NULL
)
19577 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19580 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19581 keyfile_inline_pos
++;
19582 is_keyfile_present
= 1;
19584 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19587 if (is_keyfile_present
!= 0)
19589 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19593 keyfile_len
= atoi (keyfile_len_pos
);
19595 keepass
->keyfile_len
= keyfile_len
;
19597 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19599 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19601 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19605 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19607 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19609 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19610 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19611 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19612 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19613 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19614 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19615 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19616 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19619 digest
[0] = keepass
->enc_iv
[0];
19620 digest
[1] = keepass
->enc_iv
[1];
19621 digest
[2] = keepass
->enc_iv
[2];
19622 digest
[3] = keepass
->enc_iv
[3];
19624 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19625 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19626 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19627 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19628 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19629 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19630 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19631 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19633 return (PARSER_OK
);
19636 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19638 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19640 u32
*digest
= (u32
*) hash_buf
->digest
;
19642 salt_t
*salt
= hash_buf
->salt
;
19644 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19645 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19646 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19647 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19648 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19649 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19650 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19651 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19653 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19655 uint salt_len
= input_len
- 64 - 1;
19657 char *salt_buf
= input_buf
+ 64 + 1;
19659 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19661 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19663 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19665 salt
->salt_len
= salt_len
;
19668 * we can precompute the first sha256 transform
19671 uint w
[16] = { 0 };
19673 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19674 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19675 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19676 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19677 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19678 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19679 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19680 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19681 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19682 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19683 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19684 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19685 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19686 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19687 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19688 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19690 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19692 sha256_64 (w
, pc256
);
19694 salt
->salt_buf_pc
[0] = pc256
[0];
19695 salt
->salt_buf_pc
[1] = pc256
[1];
19696 salt
->salt_buf_pc
[2] = pc256
[2];
19697 salt
->salt_buf_pc
[3] = pc256
[3];
19698 salt
->salt_buf_pc
[4] = pc256
[4];
19699 salt
->salt_buf_pc
[5] = pc256
[5];
19700 salt
->salt_buf_pc
[6] = pc256
[6];
19701 salt
->salt_buf_pc
[7] = pc256
[7];
19703 digest
[0] -= pc256
[0];
19704 digest
[1] -= pc256
[1];
19705 digest
[2] -= pc256
[2];
19706 digest
[3] -= pc256
[3];
19707 digest
[4] -= pc256
[4];
19708 digest
[5] -= pc256
[5];
19709 digest
[6] -= pc256
[6];
19710 digest
[7] -= pc256
[7];
19712 return (PARSER_OK
);
19715 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19717 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19719 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19721 u32
*digest
= (u32
*) hash_buf
->digest
;
19723 salt_t
*salt
= hash_buf
->salt
;
19729 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19731 char *data_buf_pos
= strchr (data_len_pos
, '$');
19733 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19735 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19737 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19738 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19742 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19744 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19746 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19748 u32 data_len
= atoi (data_len_pos
);
19750 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19756 char *salt_pos
= data_buf_pos
;
19758 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19759 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19760 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19761 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19763 // this is actually the CT, which is also the hash later (if matched)
19765 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19766 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19767 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19768 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19770 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19772 salt
->salt_iter
= 10 - 1;
19778 digest
[0] = salt
->salt_buf
[4];
19779 digest
[1] = salt
->salt_buf
[5];
19780 digest
[2] = salt
->salt_buf
[6];
19781 digest
[3] = salt
->salt_buf
[7];
19783 return (PARSER_OK
);
19786 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19788 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19790 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19792 u32
*digest
= (u32
*) hash_buf
->digest
;
19794 salt_t
*salt
= hash_buf
->salt
;
19800 char *salt_pos
= input_buf
+ 11 + 1;
19802 char *iter_pos
= strchr (salt_pos
, ',');
19804 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19806 u32 salt_len
= iter_pos
- salt_pos
;
19808 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19812 char *hash_pos
= strchr (iter_pos
, ',');
19814 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19816 u32 iter_len
= hash_pos
- iter_pos
;
19818 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19822 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19824 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19830 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19831 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19832 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19833 salt
->salt_buf
[3] = 0x00018000;
19835 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19836 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19837 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19838 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19840 salt
->salt_len
= salt_len
/ 2;
19842 salt
->salt_iter
= atoi (iter_pos
) - 1;
19848 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19849 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19850 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19851 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19852 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19853 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19854 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19855 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19857 return (PARSER_OK
);
19860 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19862 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19864 u32
*digest
= (u32
*) hash_buf
->digest
;
19866 salt_t
*salt
= hash_buf
->salt
;
19872 char *hash_pos
= input_buf
+ 64;
19873 char *salt1_pos
= input_buf
+ 128;
19874 char *salt2_pos
= input_buf
;
19880 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19881 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19882 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19883 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19885 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19886 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19887 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19888 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19890 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19891 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19892 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19893 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19895 salt
->salt_len
= 48;
19897 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19903 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19904 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19905 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19906 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19907 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19908 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19909 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19910 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19912 return (PARSER_OK
);
19915 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19917 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
19919 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19920 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19922 u32
*digest
= (u32
*) hash_buf
->digest
;
19924 salt_t
*salt
= hash_buf
->salt
;
19926 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
19932 char *param0_pos
= input_buf
+ 6 + 1;
19934 char *param1_pos
= strchr (param0_pos
, '*');
19936 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19938 u32 param0_len
= param1_pos
- param0_pos
;
19942 char *param2_pos
= strchr (param1_pos
, '*');
19944 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19946 u32 param1_len
= param2_pos
- param1_pos
;
19950 char *param3_pos
= strchr (param2_pos
, '*');
19952 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19954 u32 param2_len
= param3_pos
- param2_pos
;
19958 char *param4_pos
= strchr (param3_pos
, '*');
19960 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19962 u32 param3_len
= param4_pos
- param3_pos
;
19966 char *param5_pos
= strchr (param4_pos
, '*');
19968 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19970 u32 param4_len
= param5_pos
- param4_pos
;
19974 char *param6_pos
= strchr (param5_pos
, '*');
19976 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19978 u32 param5_len
= param6_pos
- param5_pos
;
19982 char *param7_pos
= strchr (param6_pos
, '*');
19984 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19986 u32 param6_len
= param7_pos
- param6_pos
;
19990 char *param8_pos
= strchr (param7_pos
, '*');
19992 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19994 u32 param7_len
= param8_pos
- param7_pos
;
19998 const uint type
= atoi (param0_pos
);
19999 const uint mode
= atoi (param1_pos
);
20000 const uint magic
= atoi (param2_pos
);
20002 char *salt_buf
= param3_pos
;
20004 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20006 const uint compress_length
= atoi (param5_pos
);
20008 char *data_buf
= param6_pos
;
20009 char *auth
= param7_pos
;
20015 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20017 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20019 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20021 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20023 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20025 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20027 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20029 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20031 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20033 if (type
!= 0) return (PARSER_SALT_VALUE
);
20035 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20037 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20039 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20047 zip2
->magic
= magic
;
20051 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20052 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20053 zip2
->salt_buf
[2] = 0;
20054 zip2
->salt_buf
[3] = 0;
20056 zip2
->salt_len
= 8;
20058 else if (mode
== 2)
20060 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20061 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20062 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20063 zip2
->salt_buf
[3] = 0;
20065 zip2
->salt_len
= 12;
20067 else if (mode
== 3)
20069 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20070 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20071 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20072 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20074 zip2
->salt_len
= 16;
20077 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20078 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20079 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20080 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20082 zip2
->verify_bytes
= verify_bytes
;
20084 zip2
->compress_length
= compress_length
;
20086 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20088 for (uint i
= 0; i
< param6_len
; i
+= 2)
20090 const char p0
= data_buf
[i
+ 0];
20091 const char p1
= data_buf
[i
+ 1];
20093 *data_buf_ptr
++ = hex_convert (p1
) << 0
20094 | hex_convert (p0
) << 4;
20099 *data_buf_ptr
= 0x80;
20101 char *auth_ptr
= (char *) zip2
->auth_buf
;
20103 for (uint i
= 0; i
< param7_len
; i
+= 2)
20105 const char p0
= auth
[i
+ 0];
20106 const char p1
= auth
[i
+ 1];
20108 *auth_ptr
++ = hex_convert (p1
) << 0
20109 | hex_convert (p0
) << 4;
20118 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20119 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20120 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20121 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20122 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20123 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20124 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20125 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20127 salt
->salt_len
= 32;
20129 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20132 * digest buf (fake)
20135 digest
[0] = zip2
->auth_buf
[0];
20136 digest
[1] = zip2
->auth_buf
[1];
20137 digest
[2] = zip2
->auth_buf
[2];
20138 digest
[3] = zip2
->auth_buf
[3];
20140 return (PARSER_OK
);
20144 * parallel running threads
20149 BOOL WINAPI
sigHandler_default (DWORD sig
)
20153 case CTRL_CLOSE_EVENT
:
20156 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20157 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20158 * function otherwise it is too late (e.g. after returning from this function)
20163 SetConsoleCtrlHandler (NULL
, TRUE
);
20170 case CTRL_LOGOFF_EVENT
:
20171 case CTRL_SHUTDOWN_EVENT
:
20175 SetConsoleCtrlHandler (NULL
, TRUE
);
20183 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20187 case CTRL_CLOSE_EVENT
:
20191 SetConsoleCtrlHandler (NULL
, TRUE
);
20198 case CTRL_LOGOFF_EVENT
:
20199 case CTRL_SHUTDOWN_EVENT
:
20203 SetConsoleCtrlHandler (NULL
, TRUE
);
20211 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20213 if (callback
== NULL
)
20215 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20219 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20225 void sigHandler_default (int sig
)
20229 signal (sig
, NULL
);
20232 void sigHandler_benchmark (int sig
)
20236 signal (sig
, NULL
);
20239 void hc_signal (void (callback
) (int))
20241 if (callback
== NULL
) callback
= SIG_DFL
;
20243 signal (SIGINT
, callback
);
20244 signal (SIGTERM
, callback
);
20245 signal (SIGABRT
, callback
);
20250 void status_display ();
20252 void *thread_keypress (void *p
)
20254 int benchmark
= *((int *) p
);
20256 uint quiet
= data
.quiet
;
20260 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20262 int ch
= tty_getchar();
20264 if (ch
== -1) break;
20266 if (ch
== 0) continue;
20268 //https://github.com/hashcat/hashcat/issues/302
20273 hc_thread_mutex_lock (mux_display
);
20289 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20290 if (quiet
== 0) fflush (stdout
);
20302 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20303 if (quiet
== 0) fflush (stdout
);
20315 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20316 if (quiet
== 0) fflush (stdout
);
20328 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20329 if (quiet
== 0) fflush (stdout
);
20337 if (benchmark
== 1) break;
20339 stop_at_checkpoint ();
20343 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20344 if (quiet
== 0) fflush (stdout
);
20352 if (benchmark
== 1)
20364 //https://github.com/hashcat/hashcat/issues/302
20369 hc_thread_mutex_unlock (mux_display
);
20381 bool class_num (const u8 c
)
20383 return ((c
>= '0') && (c
<= '9'));
20386 bool class_lower (const u8 c
)
20388 return ((c
>= 'a') && (c
<= 'z'));
20391 bool class_upper (const u8 c
)
20393 return ((c
>= 'A') && (c
<= 'Z'));
20396 bool class_alpha (const u8 c
)
20398 return (class_lower (c
) || class_upper (c
));
20401 int conv_ctoi (const u8 c
)
20407 else if (class_upper (c
))
20409 return c
- 'A' + 10;
20415 int conv_itoc (const u8 c
)
20423 return c
+ 'A' - 10;
20433 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20434 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20435 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20436 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20437 #define MAX_KERNEL_RULES 255
20438 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20439 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20440 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20442 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20443 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20444 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20445 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20447 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20452 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20454 switch (rule_buf
[rule_pos
])
20460 case RULE_OP_MANGLE_NOOP
:
20461 SET_NAME (rule
, rule_buf
[rule_pos
]);
20464 case RULE_OP_MANGLE_LREST
:
20465 SET_NAME (rule
, rule_buf
[rule_pos
]);
20468 case RULE_OP_MANGLE_UREST
:
20469 SET_NAME (rule
, rule_buf
[rule_pos
]);
20472 case RULE_OP_MANGLE_LREST_UFIRST
:
20473 SET_NAME (rule
, rule_buf
[rule_pos
]);
20476 case RULE_OP_MANGLE_UREST_LFIRST
:
20477 SET_NAME (rule
, rule_buf
[rule_pos
]);
20480 case RULE_OP_MANGLE_TREST
:
20481 SET_NAME (rule
, rule_buf
[rule_pos
]);
20484 case RULE_OP_MANGLE_TOGGLE_AT
:
20485 SET_NAME (rule
, rule_buf
[rule_pos
]);
20486 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20489 case RULE_OP_MANGLE_REVERSE
:
20490 SET_NAME (rule
, rule_buf
[rule_pos
]);
20493 case RULE_OP_MANGLE_DUPEWORD
:
20494 SET_NAME (rule
, rule_buf
[rule_pos
]);
20497 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20498 SET_NAME (rule
, rule_buf
[rule_pos
]);
20499 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20502 case RULE_OP_MANGLE_REFLECT
:
20503 SET_NAME (rule
, rule_buf
[rule_pos
]);
20506 case RULE_OP_MANGLE_ROTATE_LEFT
:
20507 SET_NAME (rule
, rule_buf
[rule_pos
]);
20510 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20511 SET_NAME (rule
, rule_buf
[rule_pos
]);
20514 case RULE_OP_MANGLE_APPEND
:
20515 SET_NAME (rule
, rule_buf
[rule_pos
]);
20516 SET_P0 (rule
, rule_buf
[rule_pos
]);
20519 case RULE_OP_MANGLE_PREPEND
:
20520 SET_NAME (rule
, rule_buf
[rule_pos
]);
20521 SET_P0 (rule
, rule_buf
[rule_pos
]);
20524 case RULE_OP_MANGLE_DELETE_FIRST
:
20525 SET_NAME (rule
, rule_buf
[rule_pos
]);
20528 case RULE_OP_MANGLE_DELETE_LAST
:
20529 SET_NAME (rule
, rule_buf
[rule_pos
]);
20532 case RULE_OP_MANGLE_DELETE_AT
:
20533 SET_NAME (rule
, rule_buf
[rule_pos
]);
20534 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20537 case RULE_OP_MANGLE_EXTRACT
:
20538 SET_NAME (rule
, rule_buf
[rule_pos
]);
20539 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20540 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20543 case RULE_OP_MANGLE_OMIT
:
20544 SET_NAME (rule
, rule_buf
[rule_pos
]);
20545 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20546 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20549 case RULE_OP_MANGLE_INSERT
:
20550 SET_NAME (rule
, rule_buf
[rule_pos
]);
20551 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20552 SET_P1 (rule
, rule_buf
[rule_pos
]);
20555 case RULE_OP_MANGLE_OVERSTRIKE
:
20556 SET_NAME (rule
, rule_buf
[rule_pos
]);
20557 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20558 SET_P1 (rule
, rule_buf
[rule_pos
]);
20561 case RULE_OP_MANGLE_TRUNCATE_AT
:
20562 SET_NAME (rule
, rule_buf
[rule_pos
]);
20563 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20566 case RULE_OP_MANGLE_REPLACE
:
20567 SET_NAME (rule
, rule_buf
[rule_pos
]);
20568 SET_P0 (rule
, rule_buf
[rule_pos
]);
20569 SET_P1 (rule
, rule_buf
[rule_pos
]);
20572 case RULE_OP_MANGLE_PURGECHAR
:
20576 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20580 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20581 SET_NAME (rule
, rule_buf
[rule_pos
]);
20582 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20585 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20586 SET_NAME (rule
, rule_buf
[rule_pos
]);
20587 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20590 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20591 SET_NAME (rule
, rule_buf
[rule_pos
]);
20594 case RULE_OP_MANGLE_SWITCH_FIRST
:
20595 SET_NAME (rule
, rule_buf
[rule_pos
]);
20598 case RULE_OP_MANGLE_SWITCH_LAST
:
20599 SET_NAME (rule
, rule_buf
[rule_pos
]);
20602 case RULE_OP_MANGLE_SWITCH_AT
:
20603 SET_NAME (rule
, rule_buf
[rule_pos
]);
20604 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20605 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20608 case RULE_OP_MANGLE_CHR_SHIFTL
:
20609 SET_NAME (rule
, rule_buf
[rule_pos
]);
20610 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20613 case RULE_OP_MANGLE_CHR_SHIFTR
:
20614 SET_NAME (rule
, rule_buf
[rule_pos
]);
20615 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20618 case RULE_OP_MANGLE_CHR_INCR
:
20619 SET_NAME (rule
, rule_buf
[rule_pos
]);
20620 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20623 case RULE_OP_MANGLE_CHR_DECR
:
20624 SET_NAME (rule
, rule_buf
[rule_pos
]);
20625 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20628 case RULE_OP_MANGLE_REPLACE_NP1
:
20629 SET_NAME (rule
, rule_buf
[rule_pos
]);
20630 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20633 case RULE_OP_MANGLE_REPLACE_NM1
:
20634 SET_NAME (rule
, rule_buf
[rule_pos
]);
20635 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20638 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20639 SET_NAME (rule
, rule_buf
[rule_pos
]);
20640 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20643 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20644 SET_NAME (rule
, rule_buf
[rule_pos
]);
20645 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20648 case RULE_OP_MANGLE_TITLE
:
20649 SET_NAME (rule
, rule_buf
[rule_pos
]);
20658 if (rule_pos
< rule_len
) return (-1);
20663 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20667 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20671 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20675 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20679 case RULE_OP_MANGLE_NOOP
:
20680 rule_buf
[rule_pos
] = rule_cmd
;
20683 case RULE_OP_MANGLE_LREST
:
20684 rule_buf
[rule_pos
] = rule_cmd
;
20687 case RULE_OP_MANGLE_UREST
:
20688 rule_buf
[rule_pos
] = rule_cmd
;
20691 case RULE_OP_MANGLE_LREST_UFIRST
:
20692 rule_buf
[rule_pos
] = rule_cmd
;
20695 case RULE_OP_MANGLE_UREST_LFIRST
:
20696 rule_buf
[rule_pos
] = rule_cmd
;
20699 case RULE_OP_MANGLE_TREST
:
20700 rule_buf
[rule_pos
] = rule_cmd
;
20703 case RULE_OP_MANGLE_TOGGLE_AT
:
20704 rule_buf
[rule_pos
] = rule_cmd
;
20705 GET_P0_CONV (rule
);
20708 case RULE_OP_MANGLE_REVERSE
:
20709 rule_buf
[rule_pos
] = rule_cmd
;
20712 case RULE_OP_MANGLE_DUPEWORD
:
20713 rule_buf
[rule_pos
] = rule_cmd
;
20716 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20717 rule_buf
[rule_pos
] = rule_cmd
;
20718 GET_P0_CONV (rule
);
20721 case RULE_OP_MANGLE_REFLECT
:
20722 rule_buf
[rule_pos
] = rule_cmd
;
20725 case RULE_OP_MANGLE_ROTATE_LEFT
:
20726 rule_buf
[rule_pos
] = rule_cmd
;
20729 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20730 rule_buf
[rule_pos
] = rule_cmd
;
20733 case RULE_OP_MANGLE_APPEND
:
20734 rule_buf
[rule_pos
] = rule_cmd
;
20738 case RULE_OP_MANGLE_PREPEND
:
20739 rule_buf
[rule_pos
] = rule_cmd
;
20743 case RULE_OP_MANGLE_DELETE_FIRST
:
20744 rule_buf
[rule_pos
] = rule_cmd
;
20747 case RULE_OP_MANGLE_DELETE_LAST
:
20748 rule_buf
[rule_pos
] = rule_cmd
;
20751 case RULE_OP_MANGLE_DELETE_AT
:
20752 rule_buf
[rule_pos
] = rule_cmd
;
20753 GET_P0_CONV (rule
);
20756 case RULE_OP_MANGLE_EXTRACT
:
20757 rule_buf
[rule_pos
] = rule_cmd
;
20758 GET_P0_CONV (rule
);
20759 GET_P1_CONV (rule
);
20762 case RULE_OP_MANGLE_OMIT
:
20763 rule_buf
[rule_pos
] = rule_cmd
;
20764 GET_P0_CONV (rule
);
20765 GET_P1_CONV (rule
);
20768 case RULE_OP_MANGLE_INSERT
:
20769 rule_buf
[rule_pos
] = rule_cmd
;
20770 GET_P0_CONV (rule
);
20774 case RULE_OP_MANGLE_OVERSTRIKE
:
20775 rule_buf
[rule_pos
] = rule_cmd
;
20776 GET_P0_CONV (rule
);
20780 case RULE_OP_MANGLE_TRUNCATE_AT
:
20781 rule_buf
[rule_pos
] = rule_cmd
;
20782 GET_P0_CONV (rule
);
20785 case RULE_OP_MANGLE_REPLACE
:
20786 rule_buf
[rule_pos
] = rule_cmd
;
20791 case RULE_OP_MANGLE_PURGECHAR
:
20795 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20799 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20800 rule_buf
[rule_pos
] = rule_cmd
;
20801 GET_P0_CONV (rule
);
20804 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20805 rule_buf
[rule_pos
] = rule_cmd
;
20806 GET_P0_CONV (rule
);
20809 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20810 rule_buf
[rule_pos
] = rule_cmd
;
20813 case RULE_OP_MANGLE_SWITCH_FIRST
:
20814 rule_buf
[rule_pos
] = rule_cmd
;
20817 case RULE_OP_MANGLE_SWITCH_LAST
:
20818 rule_buf
[rule_pos
] = rule_cmd
;
20821 case RULE_OP_MANGLE_SWITCH_AT
:
20822 rule_buf
[rule_pos
] = rule_cmd
;
20823 GET_P0_CONV (rule
);
20824 GET_P1_CONV (rule
);
20827 case RULE_OP_MANGLE_CHR_SHIFTL
:
20828 rule_buf
[rule_pos
] = rule_cmd
;
20829 GET_P0_CONV (rule
);
20832 case RULE_OP_MANGLE_CHR_SHIFTR
:
20833 rule_buf
[rule_pos
] = rule_cmd
;
20834 GET_P0_CONV (rule
);
20837 case RULE_OP_MANGLE_CHR_INCR
:
20838 rule_buf
[rule_pos
] = rule_cmd
;
20839 GET_P0_CONV (rule
);
20842 case RULE_OP_MANGLE_CHR_DECR
:
20843 rule_buf
[rule_pos
] = rule_cmd
;
20844 GET_P0_CONV (rule
);
20847 case RULE_OP_MANGLE_REPLACE_NP1
:
20848 rule_buf
[rule_pos
] = rule_cmd
;
20849 GET_P0_CONV (rule
);
20852 case RULE_OP_MANGLE_REPLACE_NM1
:
20853 rule_buf
[rule_pos
] = rule_cmd
;
20854 GET_P0_CONV (rule
);
20857 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20858 rule_buf
[rule_pos
] = rule_cmd
;
20859 GET_P0_CONV (rule
);
20862 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20863 rule_buf
[rule_pos
] = rule_cmd
;
20864 GET_P0_CONV (rule
);
20867 case RULE_OP_MANGLE_TITLE
:
20868 rule_buf
[rule_pos
] = rule_cmd
;
20872 return rule_pos
- 1;
20890 * CPU rules : this is from hashcat sources, cpu based rules
20893 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20894 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20896 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20897 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20898 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20900 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20901 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20902 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20904 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20908 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20913 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20917 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20922 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20926 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20931 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20936 for (l
= 0; l
< arr_len
; l
++)
20938 r
= arr_len
- 1 - l
;
20942 MANGLE_SWITCH (arr
, l
, r
);
20948 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20950 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20952 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20954 return (arr_len
* 2);
20957 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20959 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20961 int orig_len
= arr_len
;
20965 for (i
= 0; i
< times
; i
++)
20967 memcpy (&arr
[arr_len
], arr
, orig_len
);
20969 arr_len
+= orig_len
;
20975 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20977 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20979 mangle_double (arr
, arr_len
);
20981 mangle_reverse (arr
+ arr_len
, arr_len
);
20983 return (arr_len
* 2);
20986 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20991 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20993 MANGLE_SWITCH (arr
, l
, r
);
20999 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21004 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21006 MANGLE_SWITCH (arr
, l
, r
);
21012 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21014 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21018 return (arr_len
+ 1);
21021 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21023 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21027 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21029 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21034 return (arr_len
+ 1);
21037 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21039 if (upos
>= arr_len
) return (arr_len
);
21043 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21045 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21048 return (arr_len
- 1);
21051 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21053 if (upos
>= arr_len
) return (arr_len
);
21055 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21059 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21061 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21067 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21069 if (upos
>= arr_len
) return (arr_len
);
21071 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21075 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21077 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21080 return (arr_len
- ulen
);
21083 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21085 if (upos
>= arr_len
) return (arr_len
);
21087 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21091 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21093 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21098 return (arr_len
+ 1);
21101 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
)
21103 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21105 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21107 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21109 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21111 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21113 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21115 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21117 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21119 return (arr_len
+ arr2_cpy
);
21122 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21124 if (upos
>= arr_len
) return (arr_len
);
21131 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21133 if (upos
>= arr_len
) return (arr_len
);
21135 memset (arr
+ upos
, 0, arr_len
- upos
);
21140 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21144 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21146 if (arr
[arr_pos
] != oldc
) continue;
21148 arr
[arr_pos
] = newc
;
21154 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21160 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21162 if (arr
[arr_pos
] == c
) continue;
21164 arr
[ret_len
] = arr
[arr_pos
];
21172 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21174 if (ulen
> arr_len
) return (arr_len
);
21176 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21178 char cs
[100] = { 0 };
21180 memcpy (cs
, arr
, ulen
);
21184 for (i
= 0; i
< ulen
; i
++)
21188 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21194 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21196 if (ulen
> arr_len
) return (arr_len
);
21198 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21200 int upos
= arr_len
- ulen
;
21204 for (i
= 0; i
< ulen
; i
++)
21206 char c
= arr
[upos
+ i
];
21208 arr_len
= mangle_append (arr
, arr_len
, c
);
21214 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21216 if ( arr_len
== 0) return (arr_len
);
21217 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21219 char c
= arr
[upos
];
21223 for (i
= 0; i
< ulen
; i
++)
21225 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21231 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21233 if ( arr_len
== 0) return (arr_len
);
21234 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21238 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21240 int new_pos
= arr_pos
* 2;
21242 arr
[new_pos
] = arr
[arr_pos
];
21244 arr
[new_pos
+ 1] = arr
[arr_pos
];
21247 return (arr_len
* 2);
21250 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21252 if (upos
>= arr_len
) return (arr_len
);
21253 if (upos2
>= arr_len
) return (arr_len
);
21255 MANGLE_SWITCH (arr
, upos
, upos2
);
21260 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21262 MANGLE_SWITCH (arr
, upos
, upos2
);
21267 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21269 if (upos
>= arr_len
) return (arr_len
);
21276 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21278 if (upos
>= arr_len
) return (arr_len
);
21285 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21287 if (upos
>= arr_len
) return (arr_len
);
21294 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21296 if (upos
>= arr_len
) return (arr_len
);
21303 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21305 int upper_next
= 1;
21309 for (pos
= 0; pos
< arr_len
; pos
++)
21311 if (arr
[pos
] == ' ')
21322 MANGLE_UPPER_AT (arr
, pos
);
21326 MANGLE_LOWER_AT (arr
, pos
);
21333 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21335 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21341 for (j
= 0; j
< rp_gen_num
; j
++)
21348 switch ((char) get_random_num (0, 9))
21351 r
= get_random_num (0, sizeof (grp_op_nop
));
21352 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21356 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21357 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21358 p1
= get_random_num (0, sizeof (grp_pos
));
21359 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21363 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21364 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21365 p1
= get_random_num (1, 6);
21366 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21370 r
= get_random_num (0, sizeof (grp_op_chr
));
21371 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21372 p1
= get_random_num (0x20, 0x7e);
21373 rule_buf
[rule_pos
++] = (char) p1
;
21377 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21378 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21379 p1
= get_random_num (0x20, 0x7e);
21380 rule_buf
[rule_pos
++] = (char) p1
;
21381 p2
= get_random_num (0x20, 0x7e);
21383 p2
= get_random_num (0x20, 0x7e);
21384 rule_buf
[rule_pos
++] = (char) p2
;
21388 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21389 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21390 p1
= get_random_num (0, sizeof (grp_pos
));
21391 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21392 p2
= get_random_num (0x20, 0x7e);
21393 rule_buf
[rule_pos
++] = (char) p2
;
21397 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21398 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21399 p1
= get_random_num (0, sizeof (grp_pos
));
21400 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21401 p2
= get_random_num (0, sizeof (grp_pos
));
21403 p2
= get_random_num (0, sizeof (grp_pos
));
21404 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21408 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21409 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21410 p1
= get_random_num (0, sizeof (grp_pos
));
21411 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21412 p2
= get_random_num (1, sizeof (grp_pos
));
21414 p2
= get_random_num (1, sizeof (grp_pos
));
21415 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21419 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21420 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21421 p1
= get_random_num (0, sizeof (grp_pos
));
21422 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21423 p2
= get_random_num (1, sizeof (grp_pos
));
21424 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21425 p3
= get_random_num (0, sizeof (grp_pos
));
21426 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21434 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21436 char mem
[BLOCK_SIZE
] = { 0 };
21438 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21440 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21442 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21444 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21446 int out_len
= in_len
;
21447 int mem_len
= in_len
;
21449 memcpy (out
, in
, out_len
);
21453 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21458 switch (rule
[rule_pos
])
21463 case RULE_OP_MANGLE_NOOP
:
21466 case RULE_OP_MANGLE_LREST
:
21467 out_len
= mangle_lrest (out
, out_len
);
21470 case RULE_OP_MANGLE_UREST
:
21471 out_len
= mangle_urest (out
, out_len
);
21474 case RULE_OP_MANGLE_LREST_UFIRST
:
21475 out_len
= mangle_lrest (out
, out_len
);
21476 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21479 case RULE_OP_MANGLE_UREST_LFIRST
:
21480 out_len
= mangle_urest (out
, out_len
);
21481 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21484 case RULE_OP_MANGLE_TREST
:
21485 out_len
= mangle_trest (out
, out_len
);
21488 case RULE_OP_MANGLE_TOGGLE_AT
:
21489 NEXT_RULEPOS (rule_pos
);
21490 NEXT_RPTOI (rule
, rule_pos
, upos
);
21491 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21494 case RULE_OP_MANGLE_REVERSE
:
21495 out_len
= mangle_reverse (out
, out_len
);
21498 case RULE_OP_MANGLE_DUPEWORD
:
21499 out_len
= mangle_double (out
, out_len
);
21502 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21503 NEXT_RULEPOS (rule_pos
);
21504 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21505 out_len
= mangle_double_times (out
, out_len
, ulen
);
21508 case RULE_OP_MANGLE_REFLECT
:
21509 out_len
= mangle_reflect (out
, out_len
);
21512 case RULE_OP_MANGLE_ROTATE_LEFT
:
21513 mangle_rotate_left (out
, out_len
);
21516 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21517 mangle_rotate_right (out
, out_len
);
21520 case RULE_OP_MANGLE_APPEND
:
21521 NEXT_RULEPOS (rule_pos
);
21522 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21525 case RULE_OP_MANGLE_PREPEND
:
21526 NEXT_RULEPOS (rule_pos
);
21527 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21530 case RULE_OP_MANGLE_DELETE_FIRST
:
21531 out_len
= mangle_delete_at (out
, out_len
, 0);
21534 case RULE_OP_MANGLE_DELETE_LAST
:
21535 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21538 case RULE_OP_MANGLE_DELETE_AT
:
21539 NEXT_RULEPOS (rule_pos
);
21540 NEXT_RPTOI (rule
, rule_pos
, upos
);
21541 out_len
= mangle_delete_at (out
, out_len
, upos
);
21544 case RULE_OP_MANGLE_EXTRACT
:
21545 NEXT_RULEPOS (rule_pos
);
21546 NEXT_RPTOI (rule
, rule_pos
, upos
);
21547 NEXT_RULEPOS (rule_pos
);
21548 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21549 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21552 case RULE_OP_MANGLE_OMIT
:
21553 NEXT_RULEPOS (rule_pos
);
21554 NEXT_RPTOI (rule
, rule_pos
, upos
);
21555 NEXT_RULEPOS (rule_pos
);
21556 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21557 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21560 case RULE_OP_MANGLE_INSERT
:
21561 NEXT_RULEPOS (rule_pos
);
21562 NEXT_RPTOI (rule
, rule_pos
, upos
);
21563 NEXT_RULEPOS (rule_pos
);
21564 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21567 case RULE_OP_MANGLE_OVERSTRIKE
:
21568 NEXT_RULEPOS (rule_pos
);
21569 NEXT_RPTOI (rule
, rule_pos
, upos
);
21570 NEXT_RULEPOS (rule_pos
);
21571 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21574 case RULE_OP_MANGLE_TRUNCATE_AT
:
21575 NEXT_RULEPOS (rule_pos
);
21576 NEXT_RPTOI (rule
, rule_pos
, upos
);
21577 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21580 case RULE_OP_MANGLE_REPLACE
:
21581 NEXT_RULEPOS (rule_pos
);
21582 NEXT_RULEPOS (rule_pos
);
21583 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21586 case RULE_OP_MANGLE_PURGECHAR
:
21587 NEXT_RULEPOS (rule_pos
);
21588 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21591 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21595 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21596 NEXT_RULEPOS (rule_pos
);
21597 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21598 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21601 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21602 NEXT_RULEPOS (rule_pos
);
21603 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21604 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21607 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21608 out_len
= mangle_dupechar (out
, out_len
);
21611 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21612 NEXT_RULEPOS (rule_pos
);
21613 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21614 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21617 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21618 NEXT_RULEPOS (rule_pos
);
21619 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21620 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21623 case RULE_OP_MANGLE_SWITCH_FIRST
:
21624 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21627 case RULE_OP_MANGLE_SWITCH_LAST
:
21628 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21631 case RULE_OP_MANGLE_SWITCH_AT
:
21632 NEXT_RULEPOS (rule_pos
);
21633 NEXT_RPTOI (rule
, rule_pos
, upos
);
21634 NEXT_RULEPOS (rule_pos
);
21635 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21636 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21639 case RULE_OP_MANGLE_CHR_SHIFTL
:
21640 NEXT_RULEPOS (rule_pos
);
21641 NEXT_RPTOI (rule
, rule_pos
, upos
);
21642 mangle_chr_shiftl (out
, out_len
, upos
);
21645 case RULE_OP_MANGLE_CHR_SHIFTR
:
21646 NEXT_RULEPOS (rule_pos
);
21647 NEXT_RPTOI (rule
, rule_pos
, upos
);
21648 mangle_chr_shiftr (out
, out_len
, upos
);
21651 case RULE_OP_MANGLE_CHR_INCR
:
21652 NEXT_RULEPOS (rule_pos
);
21653 NEXT_RPTOI (rule
, rule_pos
, upos
);
21654 mangle_chr_incr (out
, out_len
, upos
);
21657 case RULE_OP_MANGLE_CHR_DECR
:
21658 NEXT_RULEPOS (rule_pos
);
21659 NEXT_RPTOI (rule
, rule_pos
, upos
);
21660 mangle_chr_decr (out
, out_len
, upos
);
21663 case RULE_OP_MANGLE_REPLACE_NP1
:
21664 NEXT_RULEPOS (rule_pos
);
21665 NEXT_RPTOI (rule
, rule_pos
, upos
);
21666 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21669 case RULE_OP_MANGLE_REPLACE_NM1
:
21670 NEXT_RULEPOS (rule_pos
);
21671 NEXT_RPTOI (rule
, rule_pos
, upos
);
21672 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21675 case RULE_OP_MANGLE_TITLE
:
21676 out_len
= mangle_title (out
, out_len
);
21679 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21680 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21681 NEXT_RULEPOS (rule_pos
);
21682 NEXT_RPTOI (rule
, rule_pos
, upos
);
21683 NEXT_RULEPOS (rule_pos
);
21684 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21685 NEXT_RULEPOS (rule_pos
);
21686 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21687 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21690 case RULE_OP_MANGLE_APPEND_MEMORY
:
21691 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21692 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21693 memcpy (out
+ out_len
, mem
, mem_len
);
21694 out_len
+= mem_len
;
21697 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21698 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21699 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21700 memcpy (mem
+ mem_len
, out
, out_len
);
21701 out_len
+= mem_len
;
21702 memcpy (out
, mem
, out_len
);
21705 case RULE_OP_MEMORIZE_WORD
:
21706 memcpy (mem
, out
, out_len
);
21710 case RULE_OP_REJECT_LESS
:
21711 NEXT_RULEPOS (rule_pos
);
21712 NEXT_RPTOI (rule
, rule_pos
, upos
);
21713 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21716 case RULE_OP_REJECT_GREATER
:
21717 NEXT_RULEPOS (rule_pos
);
21718 NEXT_RPTOI (rule
, rule_pos
, upos
);
21719 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21722 case RULE_OP_REJECT_CONTAIN
:
21723 NEXT_RULEPOS (rule_pos
);
21724 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21727 case RULE_OP_REJECT_NOT_CONTAIN
:
21728 NEXT_RULEPOS (rule_pos
);
21729 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21732 case RULE_OP_REJECT_EQUAL_FIRST
:
21733 NEXT_RULEPOS (rule_pos
);
21734 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21737 case RULE_OP_REJECT_EQUAL_LAST
:
21738 NEXT_RULEPOS (rule_pos
);
21739 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21742 case RULE_OP_REJECT_EQUAL_AT
:
21743 NEXT_RULEPOS (rule_pos
);
21744 NEXT_RPTOI (rule
, rule_pos
, upos
);
21745 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21746 NEXT_RULEPOS (rule_pos
);
21747 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21750 case RULE_OP_REJECT_CONTAINS
:
21751 NEXT_RULEPOS (rule_pos
);
21752 NEXT_RPTOI (rule
, rule_pos
, upos
);
21753 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21754 NEXT_RULEPOS (rule_pos
);
21755 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21756 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21759 case RULE_OP_REJECT_MEMORY
:
21760 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21764 return (RULE_RC_SYNTAX_ERROR
);
21769 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);