2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2675 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2677 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2679 if (iNumberAdapters
== 0)
2681 log_info ("WARN: No ADL adapters found.");
2690 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2692 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2693 ADLODParameters lpOdParameters;
2695 lpOdParameters.iSize = sizeof (ADLODParameters);
2696 size_t plevels_size = 0;
2698 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2700 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2701 __func__, iAdapterIndex,
2702 lpOdParameters.iNumberOfPerformanceLevels,
2703 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2704 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2706 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2708 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2710 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2712 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2714 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2715 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2716 __func__, iAdapterIndex, j,
2717 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2719 myfree (lpOdPerformanceLevels);
2725 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2727 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2729 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2731 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2733 return lpAdapterInfo
;
2736 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2740 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2744 log_info ("WARN: No NvAPI adapters found");
2752 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2756 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2758 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2760 // can be used to determine if the device by index matches the cuda device by index
2761 // char name[100]; memset (name, 0, sizeof (name));
2762 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2769 log_info ("WARN: No NVML adapters found");
2779 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2782 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2786 for (uint i = 0; i < num_adl_adapters; i++)
2788 int opencl_bus_num = hm_device[i].busid;
2789 int opencl_dev_num = hm_device[i].devid;
2791 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2799 if (idx >= DEVICES_MAX) return -1;
2804 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2806 for (uint i = 0; i < opencl_num_devices; i++)
2808 cl_device_topology_amd device_topology;
2810 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2812 hm_device[i].busid = device_topology.pcie.bus;
2813 hm_device[i].devid = device_topology.pcie.device;
2818 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2820 // basically bubble sort
2822 for (int i
= 0; i
< num_adl_adapters
; i
++)
2824 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2826 // get info of adapter [x]
2828 u32 adapter_index_x
= valid_adl_device_list
[j
];
2829 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2831 u32 bus_num_x
= info_x
.iBusNumber
;
2832 u32 dev_num_x
= info_x
.iDeviceNumber
;
2834 // get info of adapter [y]
2836 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2837 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2839 u32 bus_num_y
= info_y
.iBusNumber
;
2840 u32 dev_num_y
= info_y
.iDeviceNumber
;
2844 if (bus_num_y
< bus_num_x
)
2848 else if (bus_num_y
== bus_num_x
)
2850 if (dev_num_y
< dev_num_x
)
2858 u32 temp
= valid_adl_device_list
[j
+ 1];
2860 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2861 valid_adl_device_list
[j
+ 0] = temp
;
2867 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2869 *num_adl_adapters
= 0;
2871 u32
*adl_adapters
= NULL
;
2873 int *bus_numbers
= NULL
;
2874 int *device_numbers
= NULL
;
2876 for (int i
= 0; i
< iNumberAdapters
; i
++)
2878 AdapterInfo info
= lpAdapterInfo
[i
];
2880 if (strlen (info
.strUDID
) < 1) continue;
2883 if (info
.iVendorID
!= 1002) continue;
2885 if (info
.iVendorID
!= 0x1002) continue;
2888 if (info
.iBusNumber
< 0) continue;
2889 if (info
.iDeviceNumber
< 0) continue;
2893 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2895 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2902 if (found
) continue;
2904 // add it to the list
2906 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2908 adl_adapters
[*num_adl_adapters
] = i
;
2910 // rest is just bookkeeping
2912 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2913 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2916 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2918 (*num_adl_adapters
)++;
2921 myfree (bus_numbers
);
2922 myfree (device_numbers
);
2924 // sort the list by increasing bus id, device id number
2926 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2928 return adl_adapters
;
2931 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2933 // loop through all valid devices
2935 for (int i
= 0; i
< num_adl_adapters
; i
++)
2937 u32 adapter_index
= valid_adl_device_list
[i
];
2941 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2943 // unfortunately this doesn't work since bus id and dev id are not unique
2944 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2945 // if (opencl_device_index == -1) continue;
2947 int opencl_device_index
= i
;
2949 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2951 // get fanspeed info
2953 if (hm_device
[opencl_device_index
].od_version
== 5)
2955 ADLFanSpeedInfo FanSpeedInfo
;
2957 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2959 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2961 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2963 // check read and write capability in fanspeedinfo
2965 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2966 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2968 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2972 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2975 else // od_version == 6
2977 ADLOD6FanSpeedInfo faninfo
;
2979 memset (&faninfo
, 0, sizeof (faninfo
));
2981 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2983 // check read capability in fanspeedinfo
2985 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2987 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2999 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3001 for (int i
= 0; i
< num_adl_adapters
; i
++)
3003 u32 adapter_index
= valid_adl_device_list
[i
];
3007 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3009 // get overdrive version
3011 int od_supported
= 0;
3015 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3017 // store the overdrive version in hm_device
3019 // unfortunately this doesn't work since bus id and dev id are not unique
3020 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3021 // if (opencl_device_index == -1) continue;
3023 int opencl_device_index
= i
;
3025 hm_device
[opencl_device_index
].od_version
= od_version
;
3031 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3033 for (int i
= 0; i
< num_adl_adapters
; i
++)
3035 u32 adapter_index
= valid_adl_device_list
[i
];
3039 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3041 // store the iAdapterIndex in hm_device
3043 // unfortunately this doesn't work since bus id and dev id are not unique
3044 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3045 // if (opencl_device_index == -1) continue;
3047 int opencl_device_index
= i
;
3049 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3052 return num_adl_adapters
;
3055 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3057 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3059 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3063 if (data
.hm_device
[device_id
].od_version
== 5)
3067 else if (data
.hm_device
[device_id
].od_version
== 6)
3069 int CurrentValue
= 0;
3070 int DefaultValue
= 0;
3072 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3074 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3076 return DefaultValue
;
3081 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3085 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3093 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3095 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3097 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3101 if (data
.hm_device
[device_id
].od_version
== 5)
3105 else if (data
.hm_device
[device_id
].od_version
== 6)
3112 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3116 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3124 int hm_get_temperature_with_device_id (const uint device_id
)
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLTemperature Temperature
;
3136 Temperature
.iSize
= sizeof (ADLTemperature
);
3138 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3140 return Temperature
.iTemperature
/ 1000;
3142 else if (data
.hm_device
[device_id
].od_version
== 6)
3144 int Temperature
= 0;
3146 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3148 return Temperature
/ 1000;
3153 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3155 int temperature
= 0;
3157 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3165 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3167 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3169 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3171 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3175 if (data
.hm_device
[device_id
].od_version
== 5)
3177 ADLFanSpeedValue lpFanSpeedValue
;
3179 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3181 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3182 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3184 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3186 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3188 else // od_version == 6
3195 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3210 int hm_get_fanspeed_with_device_id (const uint device_id
)
3212 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3214 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3216 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3220 if (data
.hm_device
[device_id
].od_version
== 5)
3222 ADLFanSpeedValue lpFanSpeedValue
;
3224 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3226 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3227 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3228 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3230 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3232 return lpFanSpeedValue
.iFanSpeed
;
3234 else // od_version == 6
3236 ADLOD6FanSpeedInfo faninfo
;
3238 memset (&faninfo
, 0, sizeof (faninfo
));
3240 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3242 return faninfo
.iFanSpeedPercent
;
3247 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3251 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3260 int hm_get_buslanes_with_device_id (const uint device_id
)
3262 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3264 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3268 ADLPMActivity PMActivity
;
3270 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3272 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3274 return PMActivity
.iCurrentBusLanes
;
3278 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3280 unsigned int currLinkWidth
;
3282 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3284 return currLinkWidth
;
3290 int hm_get_utilization_with_device_id (const uint device_id
)
3292 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3294 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3298 ADLPMActivity PMActivity
;
3300 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3302 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3304 return PMActivity
.iActivityPercent
;
3308 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3310 nvmlUtilization_t utilization
;
3312 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3314 return utilization
.gpu
;
3320 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3322 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3324 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3328 ADLPMActivity PMActivity
;
3330 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3332 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3334 return PMActivity
.iMemoryClock
/ 100;
3338 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3342 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3350 int hm_get_corespeed_with_device_id (const uint device_id
)
3352 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3354 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3358 ADLPMActivity PMActivity
;
3360 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3362 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3364 return PMActivity
.iEngineClock
/ 100;
3368 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3372 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3380 int hm_get_throttle_with_device_id (const uint device_id
)
3382 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3384 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3389 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3391 unsigned long long clocksThrottleReasons
= 0;
3392 unsigned long long supportedThrottleReasons
= 0;
3394 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3395 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3397 clocksThrottleReasons
&= supportedThrottleReasons
;
3399 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3401 return (clocksThrottleReasons
> 0);
3407 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3409 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3413 if (data
.hm_device
[device_id
].od_version
== 5)
3415 ADLFanSpeedValue lpFanSpeedValue
;
3417 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3419 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3420 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3421 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3422 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3424 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3428 else // od_version == 6
3430 ADLOD6FanSpeedValue fan_speed_value
;
3432 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3434 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3435 fan_speed_value
.iFanSpeed
= fanspeed
;
3437 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3447 #endif // HAVE_HWMON
3453 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3455 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3457 if (css_cnt
> SP_PW_MAX
)
3459 log_error ("ERROR: mask length is too long");
3464 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3466 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3468 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3469 uint cs_len
= css
[css_pos
].cs_len
;
3471 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3473 uint c
= cs_buf
[cs_pos
] & 0xff;
3480 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3482 cs_t
*cs
= &css
[css_cnt
];
3484 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3486 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3490 for (i
= 0; i
< cs
->cs_len
; i
++)
3492 const uint u
= cs
->cs_buf
[i
];
3497 for (i
= 0; i
< in_len
; i
++)
3499 uint u
= in_buf
[i
] & 0xff;
3501 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3503 if (css_uniq
[u
] == 1) continue;
3507 cs
->cs_buf
[cs
->cs_len
] = u
;
3515 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3519 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3521 uint p0
= in_buf
[in_pos
] & 0xff;
3523 if (interpret
== 1 && p0
== '?')
3527 if (in_pos
== in_len
) break;
3529 uint p1
= in_buf
[in_pos
] & 0xff;
3533 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3535 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3537 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3539 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3541 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3543 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3545 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3546 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3548 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3549 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3551 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3552 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3554 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3555 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3557 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3559 default: log_error ("Syntax error: %s", in_buf
);
3565 if (data
.hex_charset
)
3569 if (in_pos
== in_len
)
3571 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3576 uint p1
= in_buf
[in_pos
] & 0xff;
3578 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3580 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3587 chr
= hex_convert (p1
) << 0;
3588 chr
|= hex_convert (p0
) << 4;
3590 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3596 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3602 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3606 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3608 sum
*= css
[css_pos
].cs_len
;
3614 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3616 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3621 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3623 char p0
= mask_buf
[mask_pos
];
3629 if (mask_pos
== mask_len
) break;
3631 char p1
= mask_buf
[mask_pos
];
3637 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3639 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3641 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3643 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3645 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3647 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3649 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3650 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3652 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3653 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3655 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3656 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3658 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3659 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3661 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3663 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3669 if (data
.hex_charset
)
3673 // if there is no 2nd hex character, show an error:
3675 if (mask_pos
== mask_len
)
3677 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3682 char p1
= mask_buf
[mask_pos
];
3684 // if they are not valid hex character, show an error:
3686 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3688 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3695 chr
|= hex_convert (p1
) << 0;
3696 chr
|= hex_convert (p0
) << 4;
3698 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3704 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3711 log_error ("ERROR: invalid mask length (0)");
3721 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3723 for (int i
= 0; i
< css_cnt
; i
++)
3725 uint len
= css
[i
].cs_len
;
3726 u64 next
= val
/ len
;
3727 uint pos
= val
% len
;
3728 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3733 void mp_cut_at (char *mask
, uint max
)
3737 uint mask_len
= strlen (mask
);
3739 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3741 if (mask
[i
] == '?') i
++;
3747 void mp_setup_sys (cs_t
*mp_sys
)
3751 uint donec
[CHARSIZ
] = { 0 };
3753 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3754 mp_sys
[0].cs_buf
[pos
++] = chr
;
3755 mp_sys
[0].cs_len
= pos
; }
3757 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3758 mp_sys
[1].cs_buf
[pos
++] = chr
;
3759 mp_sys
[1].cs_len
= pos
; }
3761 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3762 mp_sys
[2].cs_buf
[pos
++] = chr
;
3763 mp_sys
[2].cs_len
= pos
; }
3765 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3766 mp_sys
[3].cs_buf
[pos
++] = chr
;
3767 mp_sys
[3].cs_len
= pos
; }
3769 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3770 mp_sys
[4].cs_len
= pos
; }
3772 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3773 mp_sys
[5].cs_len
= pos
; }
3776 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3778 FILE *fp
= fopen (buf
, "rb");
3780 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3782 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3786 char mp_file
[1024] = { 0 };
3788 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3792 len
= in_superchop (mp_file
);
3796 log_info ("WARNING: charset file corrupted");
3798 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3802 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3807 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3809 mp_usr
[index
].cs_len
= 0;
3811 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3814 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3816 char *new_mask_buf
= (char *) mymalloc (256);
3822 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3824 if (css_pos
== len
) break;
3826 char p0
= mask_buf
[mask_pos
];
3828 new_mask_buf
[mask_pos
] = p0
;
3834 if (mask_pos
== mask_len
) break;
3836 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3840 if (data
.hex_charset
)
3844 if (mask_pos
== mask_len
)
3846 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3851 char p1
= mask_buf
[mask_pos
];
3853 // if they are not valid hex character, show an error:
3855 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3857 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3862 new_mask_buf
[mask_pos
] = p1
;
3867 if (css_pos
== len
) return (new_mask_buf
);
3869 myfree (new_mask_buf
);
3878 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3884 for (i
= start
; i
< stop
; i
++)
3886 sum
*= root_css_buf
[i
].cs_len
;
3892 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3896 cs_t
*cs
= &root_css_buf
[start
];
3900 for (i
= start
; i
< stop
; i
++)
3902 const u64 m
= v
% cs
->cs_len
;
3903 const u64 d
= v
/ cs
->cs_len
;
3907 const uint k
= cs
->cs_buf
[m
];
3909 pw_buf
[i
- start
] = (char) k
;
3911 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3915 int sp_comp_val (const void *p1
, const void *p2
)
3917 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3918 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3920 return b2
->val
- b1
->val
;
3923 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3930 * Initialize hcstats
3933 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3935 u64
*root_stats_ptr
= root_stats_buf
;
3937 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3939 for (i
= 0; i
< SP_PW_MAX
; i
++)
3941 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3943 root_stats_ptr
+= CHARSIZ
;
3946 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3948 u64
*markov_stats_ptr
= markov_stats_buf
;
3950 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3952 for (i
= 0; i
< SP_PW_MAX
; i
++)
3954 for (j
= 0; j
< CHARSIZ
; j
++)
3956 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3958 markov_stats_ptr
+= CHARSIZ
;
3968 char hcstat_tmp
[256] = { 0 };
3970 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3972 hcstat
= hcstat_tmp
;
3975 FILE *fd
= fopen (hcstat
, "rb");
3979 log_error ("%s: %s", hcstat
, strerror (errno
));
3984 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3986 log_error ("%s: Could not load data", hcstat
);
3993 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3995 log_error ("%s: Could not load data", hcstat
);
4005 * Markov modifier of hcstat_table on user request
4010 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4011 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4016 /* Add all stats to first position */
4018 for (i
= 1; i
< SP_PW_MAX
; i
++)
4020 u64
*out
= root_stats_buf_by_pos
[0];
4021 u64
*in
= root_stats_buf_by_pos
[i
];
4023 for (j
= 0; j
< CHARSIZ
; j
++)
4029 for (i
= 1; i
< SP_PW_MAX
; i
++)
4031 u64
*out
= markov_stats_buf_by_key
[0][0];
4032 u64
*in
= markov_stats_buf_by_key
[i
][0];
4034 for (j
= 0; j
< CHARSIZ
; j
++)
4036 for (k
= 0; k
< CHARSIZ
; k
++)
4043 /* copy them to all pw_positions */
4045 for (i
= 1; i
< SP_PW_MAX
; i
++)
4047 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4050 for (i
= 1; i
< SP_PW_MAX
; i
++)
4052 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4060 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4062 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4064 for (i
= 0; i
< SP_PW_MAX
; i
++)
4066 root_table_buf_by_pos
[i
] = root_table_ptr
;
4068 root_table_ptr
+= CHARSIZ
;
4071 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4073 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4075 for (i
= 0; i
< SP_PW_MAX
; i
++)
4077 for (j
= 0; j
< CHARSIZ
; j
++)
4079 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4081 markov_table_ptr
+= CHARSIZ
;
4086 * Convert hcstat to tables
4089 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4091 uint key
= i
% CHARSIZ
;
4093 root_table_buf
[i
].key
= key
;
4094 root_table_buf
[i
].val
= root_stats_buf
[i
];
4097 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4099 uint key
= i
% CHARSIZ
;
4101 markov_table_buf
[i
].key
= key
;
4102 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4105 myfree (root_stats_buf
);
4106 myfree (markov_stats_buf
);
4112 for (i
= 0; i
< SP_PW_MAX
; i
++)
4114 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4117 for (i
= 0; i
< SP_PW_MAX
; i
++)
4119 for (j
= 0; j
< CHARSIZ
; j
++)
4121 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4126 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4129 * Convert tables to css
4132 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4134 uint pw_pos
= i
/ CHARSIZ
;
4136 cs_t
*cs
= &root_css_buf
[pw_pos
];
4138 if (cs
->cs_len
== threshold
) continue;
4140 uint key
= root_table_buf
[i
].key
;
4142 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4144 cs
->cs_buf
[cs
->cs_len
] = key
;
4150 * Convert table to css
4153 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4155 uint c
= i
/ CHARSIZ
;
4157 cs_t
*cs
= &markov_css_buf
[c
];
4159 if (cs
->cs_len
== threshold
) continue;
4161 uint pw_pos
= c
/ CHARSIZ
;
4163 uint key
= markov_table_buf
[i
].key
;
4165 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4167 cs
->cs_buf
[cs
->cs_len
] = key
;
4173 for (uint i = 0; i < 8; i++)
4175 for (uint j = 0x20; j < 0x80; j++)
4177 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4179 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4181 for (uint k = 0; k < 10; k++)
4183 printf (" %u\n", ptr->cs_buf[k]);
4190 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4192 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4194 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4204 for (uint j
= 1; j
< CHARSIZ
; j
++)
4214 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4216 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4218 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4220 out
+= CHARSIZ
* CHARSIZ
;
4221 in
+= CHARSIZ
* CHARSIZ
;
4223 for (uint j
= 0; j
< CHARSIZ
; j
++)
4230 for (uint k
= 1; k
< CHARSIZ
; k
++)
4242 * mixed shared functions
4245 void dump_hex (const u8
*s
, const int sz
)
4247 for (int i
= 0; i
< sz
; i
++)
4249 log_info_nn ("%02x ", s
[i
]);
4255 void usage_mini_print (const char *progname
)
4257 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4260 void usage_big_print (const char *progname
)
4262 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4265 char *get_exec_path ()
4267 int exec_path_len
= 1024;
4269 char *exec_path
= (char *) mymalloc (exec_path_len
);
4273 char tmp
[32] = { 0 };
4275 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4277 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4281 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4285 uint size
= exec_path_len
;
4287 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4289 log_error("! executable path buffer too small\n");
4294 const int len
= strlen (exec_path
);
4297 #error Your Operating System is not supported or detected
4305 char *get_install_dir (const char *progname
)
4307 char *install_dir
= mystrdup (progname
);
4308 char *last_slash
= NULL
;
4310 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4314 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4320 install_dir
[0] = '.';
4324 return (install_dir
);
4327 char *get_profile_dir (const char *homedir
)
4329 #define DOT_HASHCAT ".hashcat"
4331 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4333 char *profile_dir
= (char *) mymalloc (len
+ 1);
4335 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4340 char *get_session_dir (const char *profile_dir
)
4342 #define SESSIONS_FOLDER "sessions"
4344 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4346 char *session_dir
= (char *) mymalloc (len
+ 1);
4348 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4353 uint
count_lines (FILE *fd
)
4357 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4363 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4365 if (nread
< 1) continue;
4369 for (i
= 0; i
< nread
; i
++)
4371 if (prev
== '\n') cnt
++;
4382 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4386 FILE *fd
= fopen (filename
, "rb");
4390 log_error ("%s: %s", filename
, strerror (errno
));
4395 #define MAX_KEY_SIZE (1024 * 1024)
4397 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4399 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4405 for (int fpos
= 0; fpos
< nread
; fpos
++)
4407 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4409 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4410 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4411 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4412 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4414 if (kpos
>= 64) kpos
= 0;
4421 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4425 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4426 if (CPU_ISSET(core
, cpu_set
)) break;
4428 thread_affinity_policy_data_t policy
= { core
};
4430 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4432 if (data
.quiet
== 0)
4434 if (rc
!= KERN_SUCCESS
)
4436 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4444 void set_cpu_affinity (char *cpu_affinity
)
4447 DWORD_PTR aff_mask
= 0;
4455 char *devices
= strdup (cpu_affinity
);
4457 char *next
= strtok (devices
, ",");
4461 uint cpu_id
= atoi (next
);
4476 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4482 aff_mask
|= 1 << (cpu_id
- 1);
4484 CPU_SET ((cpu_id
- 1), &cpuset
);
4487 } while ((next
= strtok (NULL
, ",")) != NULL
);
4493 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4494 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4496 pthread_t thread
= pthread_self ();
4497 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4501 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4503 char *element
, *end
;
4505 end
= (char *) base
+ nmemb
* size
;
4507 for (element
= (char *) base
; element
< end
; element
+= size
)
4508 if (!compar (element
, key
))
4514 int sort_by_u32 (const void *v1
, const void *v2
)
4516 const u32
*s1
= (const u32
*) v1
;
4517 const u32
*s2
= (const u32
*) v2
;
4522 int sort_by_salt (const void *v1
, const void *v2
)
4524 const salt_t
*s1
= (const salt_t
*) v1
;
4525 const salt_t
*s2
= (const salt_t
*) v2
;
4527 const int res1
= s1
->salt_len
- s2
->salt_len
;
4529 if (res1
!= 0) return (res1
);
4531 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4533 if (res2
!= 0) return (res2
);
4541 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4542 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4549 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4550 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4556 int sort_by_salt_buf (const void *v1
, const void *v2
)
4558 const pot_t
*p1
= (const pot_t
*) v1
;
4559 const pot_t
*p2
= (const pot_t
*) v2
;
4561 const hash_t
*h1
= &p1
->hash
;
4562 const hash_t
*h2
= &p2
->hash
;
4564 const salt_t
*s1
= h1
->salt
;
4565 const salt_t
*s2
= h2
->salt
;
4571 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4572 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4578 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4580 const hash_t
*h1
= (const hash_t
*) v1
;
4581 const hash_t
*h2
= (const hash_t
*) v2
;
4583 const salt_t
*s1
= h1
->salt
;
4584 const salt_t
*s2
= h2
->salt
;
4586 // testphase: this should work
4591 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4592 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4595 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4596 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4597 if (s1->salt_len > s2->salt_len) return ( 1);
4598 if (s1->salt_len < s2->salt_len) return (-1);
4600 uint n = s1->salt_len;
4604 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4605 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4612 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4614 const hash_t
*h1
= (const hash_t
*) v1
;
4615 const hash_t
*h2
= (const hash_t
*) v2
;
4617 const salt_t
*s1
= h1
->salt
;
4618 const salt_t
*s2
= h2
->salt
;
4620 // 16 - 2 (since last 2 uints contain the digest)
4625 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4626 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4632 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4634 const hash_t
*h1
= (const hash_t
*) v1
;
4635 const hash_t
*h2
= (const hash_t
*) v2
;
4637 const void *d1
= h1
->digest
;
4638 const void *d2
= h2
->digest
;
4640 return data
.sort_by_digest (d1
, d2
);
4643 int sort_by_hash (const void *v1
, const void *v2
)
4645 const hash_t
*h1
= (const hash_t
*) v1
;
4646 const hash_t
*h2
= (const hash_t
*) v2
;
4650 const salt_t
*s1
= h1
->salt
;
4651 const salt_t
*s2
= h2
->salt
;
4653 int res
= sort_by_salt (s1
, s2
);
4655 if (res
!= 0) return (res
);
4658 const void *d1
= h1
->digest
;
4659 const void *d2
= h2
->digest
;
4661 return data
.sort_by_digest (d1
, d2
);
4664 int sort_by_pot (const void *v1
, const void *v2
)
4666 const pot_t
*p1
= (const pot_t
*) v1
;
4667 const pot_t
*p2
= (const pot_t
*) v2
;
4669 const hash_t
*h1
= &p1
->hash
;
4670 const hash_t
*h2
= &p2
->hash
;
4672 return sort_by_hash (h1
, h2
);
4675 int sort_by_mtime (const void *p1
, const void *p2
)
4677 const char **f1
= (const char **) p1
;
4678 const char **f2
= (const char **) p2
;
4680 struct stat s1
; stat (*f1
, &s1
);
4681 struct stat s2
; stat (*f2
, &s2
);
4683 return s2
.st_mtime
- s1
.st_mtime
;
4686 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4688 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4689 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4691 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4694 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4696 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4697 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4699 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4702 int sort_by_stringptr (const void *p1
, const void *p2
)
4704 const char **s1
= (const char **) p1
;
4705 const char **s2
= (const char **) p2
;
4707 return strcmp (*s1
, *s2
);
4710 int sort_by_dictstat (const void *s1
, const void *s2
)
4712 dictstat_t
*d1
= (dictstat_t
*) s1
;
4713 dictstat_t
*d2
= (dictstat_t
*) s2
;
4716 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4718 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4721 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4724 int sort_by_bitmap (const void *p1
, const void *p2
)
4726 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4727 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4729 return b1
->collisions
- b2
->collisions
;
4732 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4734 const u32
*d1
= (const u32
*) v1
;
4735 const u32
*d2
= (const u32
*) v2
;
4741 if (d1
[n
] > d2
[n
]) return ( 1);
4742 if (d1
[n
] < d2
[n
]) return (-1);
4748 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4750 const u32
*d1
= (const u32
*) v1
;
4751 const u32
*d2
= (const u32
*) v2
;
4757 if (d1
[n
] > d2
[n
]) return ( 1);
4758 if (d1
[n
] < d2
[n
]) return (-1);
4764 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4766 const u32
*d1
= (const u32
*) v1
;
4767 const u32
*d2
= (const u32
*) v2
;
4773 if (d1
[n
] > d2
[n
]) return ( 1);
4774 if (d1
[n
] < d2
[n
]) return (-1);
4780 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4782 const u32
*d1
= (const u32
*) v1
;
4783 const u32
*d2
= (const u32
*) v2
;
4789 if (d1
[n
] > d2
[n
]) return ( 1);
4790 if (d1
[n
] < d2
[n
]) return (-1);
4796 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4798 const u32
*d1
= (const u32
*) v1
;
4799 const u32
*d2
= (const u32
*) v2
;
4805 if (d1
[n
] > d2
[n
]) return ( 1);
4806 if (d1
[n
] < d2
[n
]) return (-1);
4812 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4814 const u32
*d1
= (const u32
*) v1
;
4815 const u32
*d2
= (const u32
*) v2
;
4821 if (d1
[n
] > d2
[n
]) return ( 1);
4822 if (d1
[n
] < d2
[n
]) return (-1);
4828 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4830 const u32
*d1
= (const u32
*) v1
;
4831 const u32
*d2
= (const u32
*) v2
;
4837 if (d1
[n
] > d2
[n
]) return ( 1);
4838 if (d1
[n
] < d2
[n
]) return (-1);
4844 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4846 const u32
*d1
= (const u32
*) v1
;
4847 const u32
*d2
= (const u32
*) v2
;
4853 if (d1
[n
] > d2
[n
]) return ( 1);
4854 if (d1
[n
] < d2
[n
]) return (-1);
4860 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4862 const u64
*d1
= (const u64
*) v1
;
4863 const u64
*d2
= (const u64
*) v2
;
4869 if (d1
[n
] > d2
[n
]) return ( 1);
4870 if (d1
[n
] < d2
[n
]) return (-1);
4876 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4878 const u64
*d1
= (const u64
*) v1
;
4879 const u64
*d2
= (const u64
*) v2
;
4885 if (d1
[n
] > d2
[n
]) return ( 1);
4886 if (d1
[n
] < d2
[n
]) return (-1);
4892 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4894 const u64
*d1
= (const u64
*) v1
;
4895 const u64
*d2
= (const u64
*) v2
;
4901 if (d1
[n
] > d2
[n
]) return ( 1);
4902 if (d1
[n
] < d2
[n
]) return (-1);
4908 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4910 const u32
*d1
= (const u32
*) v1
;
4911 const u32
*d2
= (const u32
*) v2
;
4913 const uint dgst_pos0
= data
.dgst_pos0
;
4914 const uint dgst_pos1
= data
.dgst_pos1
;
4915 const uint dgst_pos2
= data
.dgst_pos2
;
4916 const uint dgst_pos3
= data
.dgst_pos3
;
4918 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4919 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4920 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4921 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4922 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4923 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4924 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4925 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4930 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4932 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4933 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4935 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4937 if (res1
!= 0) return (res1
);
4942 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4944 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4945 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4947 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4949 if (res1
!= 0) return (res1
);
4951 const int res2
= t1
->attack_mode
4954 if (res2
!= 0) return (res2
);
4956 const int res3
= t1
->hash_type
4959 if (res3
!= 0) return (res3
);
4964 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4966 uint outfile_autohex
= data
.outfile_autohex
;
4968 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4970 FILE *debug_fp
= NULL
;
4972 if (debug_file
!= NULL
)
4974 debug_fp
= fopen (debug_file
, "ab");
4976 lock_file (debug_fp
);
4983 if (debug_fp
== NULL
)
4985 log_info ("WARNING: Could not open debug-file for writing");
4989 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4991 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4993 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4996 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4998 if (debug_mode
== 4)
5000 fputc (':', debug_fp
);
5002 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5005 fputc ('\n', debug_fp
);
5007 if (debug_file
!= NULL
) fclose (debug_fp
);
5011 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5013 int needs_hexify
= 0;
5015 if (outfile_autohex
== 1)
5017 for (uint i
= 0; i
< plain_len
; i
++)
5019 if (plain_ptr
[i
] < 0x20)
5026 if (plain_ptr
[i
] > 0x7f)
5035 if (needs_hexify
== 1)
5037 fprintf (fp
, "$HEX[");
5039 for (uint i
= 0; i
< plain_len
; i
++)
5041 fprintf (fp
, "%02x", plain_ptr
[i
]);
5048 fwrite (plain_ptr
, plain_len
, 1, fp
);
5052 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
5054 uint outfile_format
= data
.outfile_format
;
5056 char separator
= data
.separator
;
5058 if (outfile_format
& OUTFILE_FMT_HASH
)
5060 fprintf (out_fp
, "%s", out_buf
);
5062 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5064 fputc (separator
, out_fp
);
5067 else if (data
.username
)
5069 if (username
!= NULL
)
5071 for (uint i
= 0; i
< user_len
; i
++)
5073 fprintf (out_fp
, "%c", username
[i
]);
5076 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5078 fputc (separator
, out_fp
);
5083 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5085 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5087 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5089 fputc (separator
, out_fp
);
5093 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5095 for (uint i
= 0; i
< plain_len
; i
++)
5097 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5100 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5102 fputc (separator
, out_fp
);
5106 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5109 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5114 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5116 fprintf (out_fp
, "%llu", crackpos
);
5121 fputc ('\n', out_fp
);
5124 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5128 pot_key
.hash
.salt
= hashes_buf
->salt
;
5129 pot_key
.hash
.digest
= hashes_buf
->digest
;
5131 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5137 input_buf
[input_len
] = 0;
5140 unsigned char *username
= NULL
;
5145 user_t
*user
= hashes_buf
->hash_info
->user
;
5149 username
= (unsigned char *) (user
->user_name
);
5151 user_len
= user
->user_len
;
5155 // do output the line
5156 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5160 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5161 #define LM_MASKED_PLAIN "[notfound]"
5163 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5169 pot_left_key
.hash
.salt
= hash_left
->salt
;
5170 pot_left_key
.hash
.digest
= hash_left
->digest
;
5172 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5176 uint weak_hash_found
= 0;
5178 pot_t pot_right_key
;
5180 pot_right_key
.hash
.salt
= hash_right
->salt
;
5181 pot_right_key
.hash
.digest
= hash_right
->digest
;
5183 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5185 if (pot_right_ptr
== NULL
)
5187 // special case, if "weak hash"
5189 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5191 weak_hash_found
= 1;
5193 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5195 // in theory this is not needed, but we are paranoia:
5197 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5198 pot_right_ptr
->plain_len
= 0;
5202 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5204 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5209 // at least one half was found:
5213 input_buf
[input_len
] = 0;
5217 unsigned char *username
= NULL
;
5222 user_t
*user
= hash_left
->hash_info
->user
;
5226 username
= (unsigned char *) (user
->user_name
);
5228 user_len
= user
->user_len
;
5232 // mask the part which was not found
5234 uint left_part_masked
= 0;
5235 uint right_part_masked
= 0;
5237 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5239 if (pot_left_ptr
== NULL
)
5241 left_part_masked
= 1;
5243 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5245 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5247 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5248 pot_left_ptr
->plain_len
= mask_plain_len
;
5251 if (pot_right_ptr
== NULL
)
5253 right_part_masked
= 1;
5255 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5257 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5259 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5260 pot_right_ptr
->plain_len
= mask_plain_len
;
5263 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5267 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5269 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5271 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5273 // do output the line
5275 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5277 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5279 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5280 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5283 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5287 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5289 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5291 if (pot_ptr
== NULL
)
5295 input_buf
[input_len
] = 0;
5297 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5301 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5307 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5309 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5313 pot_t pot_right_key
;
5315 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5317 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5319 uint weak_hash_found
= 0;
5321 if (pot_right_ptr
== NULL
)
5323 // special case, if "weak hash"
5325 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5327 weak_hash_found
= 1;
5329 // we just need that pot_right_ptr is not a NULL pointer
5331 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5335 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5337 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5342 // ... at least one part was not cracked
5346 input_buf
[input_len
] = 0;
5348 // only show the hash part which is still not cracked
5350 uint user_len
= input_len
- 32;
5352 char *hash_output
= (char *) mymalloc (33);
5354 memcpy (hash_output
, input_buf
, input_len
);
5356 if (pot_left_ptr
!= NULL
)
5358 // only show right part (because left part was already found)
5360 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5362 hash_output
[user_len
+ 16] = 0;
5365 if (pot_right_ptr
!= NULL
)
5367 // only show left part (because right part was already found)
5369 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5371 hash_output
[user_len
+ 16] = 0;
5374 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5376 myfree (hash_output
);
5378 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5381 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5383 uint opencl_platforms_filter
= 0;
5385 if (opencl_platforms
)
5387 char *platforms
= strdup (opencl_platforms
);
5389 char *next
= strtok (platforms
, ",");
5393 int platform
= atoi (next
);
5395 if (platform
< 1 || platform
> 32)
5397 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5402 opencl_platforms_filter
|= 1 << (platform
- 1);
5404 } while ((next
= strtok (NULL
, ",")) != NULL
);
5410 opencl_platforms_filter
= -1;
5413 return opencl_platforms_filter
;
5416 u32
setup_devices_filter (char *opencl_devices
)
5418 u32 devices_filter
= 0;
5422 char *devices
= strdup (opencl_devices
);
5424 char *next
= strtok (devices
, ",");
5428 int device_id
= atoi (next
);
5430 if (device_id
< 1 || device_id
> 32)
5432 log_error ("ERROR: invalid device_id %u specified", device_id
);
5437 devices_filter
|= 1 << (device_id
- 1);
5439 } while ((next
= strtok (NULL
, ",")) != NULL
);
5445 devices_filter
= -1;
5448 return devices_filter
;
5451 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5453 cl_device_type device_types_filter
= 0;
5455 if (opencl_device_types
)
5457 char *device_types
= strdup (opencl_device_types
);
5459 char *next
= strtok (device_types
, ",");
5463 int device_type
= atoi (next
);
5465 if (device_type
< 1 || device_type
> 3)
5467 log_error ("ERROR: invalid device_type %u specified", device_type
);
5472 device_types_filter
|= 1 << device_type
;
5474 } while ((next
= strtok (NULL
, ",")) != NULL
);
5476 free (device_types
);
5480 // Do not use CPU by default, this often reduces GPU performance because
5481 // the CPU is too busy to handle GPU synchronization
5483 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5486 return device_types_filter
;
5489 u32
get_random_num (const u32 min
, const u32 max
)
5491 if (min
== max
) return (min
);
5493 return ((rand () % (max
- min
)) + min
);
5496 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5498 u32 quotient
= dividend
/ divisor
;
5500 if (dividend
% divisor
) quotient
++;
5505 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5507 u64 quotient
= dividend
/ divisor
;
5509 if (dividend
% divisor
) quotient
++;
5514 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5516 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5517 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5519 if (tm
->tm_year
- 70)
5521 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5522 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5524 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5526 else if (tm
->tm_yday
)
5528 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5529 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5531 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5533 else if (tm
->tm_hour
)
5535 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5536 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5538 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5540 else if (tm
->tm_min
)
5542 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5543 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5545 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5549 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5551 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5555 void format_speed_display (float val
, char *buf
, size_t len
)
5566 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5577 /* generate output */
5581 snprintf (buf
, len
- 1, "%.0f ", val
);
5585 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5589 void lowercase (u8
*buf
, int len
)
5591 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5594 void uppercase (u8
*buf
, int len
)
5596 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5599 int fgetl (FILE *fp
, char *line_buf
)
5605 const int c
= fgetc (fp
);
5607 if (c
== EOF
) break;
5609 line_buf
[line_len
] = (char) c
;
5613 if (line_len
== HCBUFSIZ
) line_len
--;
5615 if (c
== '\n') break;
5618 if (line_len
== 0) return 0;
5620 if (line_buf
[line_len
- 1] == '\n')
5624 line_buf
[line_len
] = 0;
5627 if (line_len
== 0) return 0;
5629 if (line_buf
[line_len
- 1] == '\r')
5633 line_buf
[line_len
] = 0;
5639 int in_superchop (char *buf
)
5641 int len
= strlen (buf
);
5645 if (buf
[len
- 1] == '\n')
5652 if (buf
[len
- 1] == '\r')
5667 char **scan_directory (const char *path
)
5669 char *tmp_path
= mystrdup (path
);
5671 size_t tmp_path_len
= strlen (tmp_path
);
5673 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5675 tmp_path
[tmp_path_len
- 1] = 0;
5677 tmp_path_len
= strlen (tmp_path
);
5680 char **files
= NULL
;
5686 if ((d
= opendir (tmp_path
)) != NULL
)
5692 memset (&e
, 0, sizeof (e
));
5693 struct dirent
*de
= NULL
;
5695 if (readdir_r (d
, &e
, &de
) != 0)
5697 log_error ("ERROR: readdir_r() failed");
5702 if (de
== NULL
) break;
5706 while ((de
= readdir (d
)) != NULL
)
5709 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5711 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5713 char *path_file
= (char *) mymalloc (path_size
+ 1);
5715 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5717 path_file
[path_size
] = 0;
5721 if ((d_test
= opendir (path_file
)) != NULL
)
5729 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5733 files
[num_files
- 1] = path_file
;
5739 else if (errno
== ENOTDIR
)
5741 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5745 files
[num_files
- 1] = mystrdup (path
);
5748 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5752 files
[num_files
- 1] = NULL
;
5759 int count_dictionaries (char **dictionary_files
)
5761 if (dictionary_files
== NULL
) return 0;
5765 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5773 char *stroptitype (const uint opti_type
)
5777 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5778 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5779 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5780 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5781 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5782 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5783 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5784 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5785 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5786 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5787 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5788 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5789 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5790 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5791 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5792 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5793 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5794 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5795 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5801 char *strparser (const uint parser_status
)
5803 switch (parser_status
)
5805 case PARSER_OK
: return ((char *) PA_000
); break;
5806 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5807 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5808 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5809 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5810 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5811 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5812 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5813 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5814 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5815 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5816 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5817 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5818 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5819 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5820 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5821 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5824 return ((char *) PA_255
);
5827 char *strhashtype (const uint hash_mode
)
5831 case 0: return ((char *) HT_00000
); break;
5832 case 10: return ((char *) HT_00010
); break;
5833 case 11: return ((char *) HT_00011
); break;
5834 case 12: return ((char *) HT_00012
); break;
5835 case 20: return ((char *) HT_00020
); break;
5836 case 21: return ((char *) HT_00021
); break;
5837 case 22: return ((char *) HT_00022
); break;
5838 case 23: return ((char *) HT_00023
); break;
5839 case 30: return ((char *) HT_00030
); break;
5840 case 40: return ((char *) HT_00040
); break;
5841 case 50: return ((char *) HT_00050
); break;
5842 case 60: return ((char *) HT_00060
); break;
5843 case 100: return ((char *) HT_00100
); break;
5844 case 101: return ((char *) HT_00101
); break;
5845 case 110: return ((char *) HT_00110
); break;
5846 case 111: return ((char *) HT_00111
); break;
5847 case 112: return ((char *) HT_00112
); break;
5848 case 120: return ((char *) HT_00120
); break;
5849 case 121: return ((char *) HT_00121
); break;
5850 case 122: return ((char *) HT_00122
); break;
5851 case 124: return ((char *) HT_00124
); break;
5852 case 125: return ((char *) HT_00125
); break;
5853 case 130: return ((char *) HT_00130
); break;
5854 case 131: return ((char *) HT_00131
); break;
5855 case 132: return ((char *) HT_00132
); break;
5856 case 133: return ((char *) HT_00133
); break;
5857 case 140: return ((char *) HT_00140
); break;
5858 case 141: return ((char *) HT_00141
); break;
5859 case 150: return ((char *) HT_00150
); break;
5860 case 160: return ((char *) HT_00160
); break;
5861 case 190: return ((char *) HT_00190
); break;
5862 case 200: return ((char *) HT_00200
); break;
5863 case 300: return ((char *) HT_00300
); break;
5864 case 400: return ((char *) HT_00400
); break;
5865 case 500: return ((char *) HT_00500
); break;
5866 case 501: return ((char *) HT_00501
); break;
5867 case 900: return ((char *) HT_00900
); break;
5868 case 910: return ((char *) HT_00910
); break;
5869 case 1000: return ((char *) HT_01000
); break;
5870 case 1100: return ((char *) HT_01100
); break;
5871 case 1400: return ((char *) HT_01400
); break;
5872 case 1410: return ((char *) HT_01410
); break;
5873 case 1420: return ((char *) HT_01420
); break;
5874 case 1421: return ((char *) HT_01421
); break;
5875 case 1430: return ((char *) HT_01430
); break;
5876 case 1440: return ((char *) HT_01440
); break;
5877 case 1441: return ((char *) HT_01441
); break;
5878 case 1450: return ((char *) HT_01450
); break;
5879 case 1460: return ((char *) HT_01460
); break;
5880 case 1500: return ((char *) HT_01500
); break;
5881 case 1600: return ((char *) HT_01600
); break;
5882 case 1700: return ((char *) HT_01700
); break;
5883 case 1710: return ((char *) HT_01710
); break;
5884 case 1711: return ((char *) HT_01711
); break;
5885 case 1720: return ((char *) HT_01720
); break;
5886 case 1722: return ((char *) HT_01722
); break;
5887 case 1730: return ((char *) HT_01730
); break;
5888 case 1731: return ((char *) HT_01731
); break;
5889 case 1740: return ((char *) HT_01740
); break;
5890 case 1750: return ((char *) HT_01750
); break;
5891 case 1760: return ((char *) HT_01760
); break;
5892 case 1800: return ((char *) HT_01800
); break;
5893 case 2100: return ((char *) HT_02100
); break;
5894 case 2400: return ((char *) HT_02400
); break;
5895 case 2410: return ((char *) HT_02410
); break;
5896 case 2500: return ((char *) HT_02500
); break;
5897 case 2600: return ((char *) HT_02600
); break;
5898 case 2611: return ((char *) HT_02611
); break;
5899 case 2612: return ((char *) HT_02612
); break;
5900 case 2711: return ((char *) HT_02711
); break;
5901 case 2811: return ((char *) HT_02811
); break;
5902 case 3000: return ((char *) HT_03000
); break;
5903 case 3100: return ((char *) HT_03100
); break;
5904 case 3200: return ((char *) HT_03200
); break;
5905 case 3710: return ((char *) HT_03710
); break;
5906 case 3711: return ((char *) HT_03711
); break;
5907 case 3800: return ((char *) HT_03800
); break;
5908 case 4300: return ((char *) HT_04300
); break;
5909 case 4400: return ((char *) HT_04400
); break;
5910 case 4500: return ((char *) HT_04500
); break;
5911 case 4700: return ((char *) HT_04700
); break;
5912 case 4800: return ((char *) HT_04800
); break;
5913 case 4900: return ((char *) HT_04900
); break;
5914 case 5000: return ((char *) HT_05000
); break;
5915 case 5100: return ((char *) HT_05100
); break;
5916 case 5200: return ((char *) HT_05200
); break;
5917 case 5300: return ((char *) HT_05300
); break;
5918 case 5400: return ((char *) HT_05400
); break;
5919 case 5500: return ((char *) HT_05500
); break;
5920 case 5600: return ((char *) HT_05600
); break;
5921 case 5700: return ((char *) HT_05700
); break;
5922 case 5800: return ((char *) HT_05800
); break;
5923 case 6000: return ((char *) HT_06000
); break;
5924 case 6100: return ((char *) HT_06100
); break;
5925 case 6211: return ((char *) HT_06211
); break;
5926 case 6212: return ((char *) HT_06212
); break;
5927 case 6213: return ((char *) HT_06213
); break;
5928 case 6221: return ((char *) HT_06221
); break;
5929 case 6222: return ((char *) HT_06222
); break;
5930 case 6223: return ((char *) HT_06223
); break;
5931 case 6231: return ((char *) HT_06231
); break;
5932 case 6232: return ((char *) HT_06232
); break;
5933 case 6233: return ((char *) HT_06233
); break;
5934 case 6241: return ((char *) HT_06241
); break;
5935 case 6242: return ((char *) HT_06242
); break;
5936 case 6243: return ((char *) HT_06243
); break;
5937 case 6300: return ((char *) HT_06300
); break;
5938 case 6400: return ((char *) HT_06400
); break;
5939 case 6500: return ((char *) HT_06500
); break;
5940 case 6600: return ((char *) HT_06600
); break;
5941 case 6700: return ((char *) HT_06700
); break;
5942 case 6800: return ((char *) HT_06800
); break;
5943 case 6900: return ((char *) HT_06900
); break;
5944 case 7100: return ((char *) HT_07100
); break;
5945 case 7200: return ((char *) HT_07200
); break;
5946 case 7300: return ((char *) HT_07300
); break;
5947 case 7400: return ((char *) HT_07400
); break;
5948 case 7500: return ((char *) HT_07500
); break;
5949 case 7600: return ((char *) HT_07600
); break;
5950 case 7700: return ((char *) HT_07700
); break;
5951 case 7800: return ((char *) HT_07800
); break;
5952 case 7900: return ((char *) HT_07900
); break;
5953 case 8000: return ((char *) HT_08000
); break;
5954 case 8100: return ((char *) HT_08100
); break;
5955 case 8200: return ((char *) HT_08200
); break;
5956 case 8300: return ((char *) HT_08300
); break;
5957 case 8400: return ((char *) HT_08400
); break;
5958 case 8500: return ((char *) HT_08500
); break;
5959 case 8600: return ((char *) HT_08600
); break;
5960 case 8700: return ((char *) HT_08700
); break;
5961 case 8800: return ((char *) HT_08800
); break;
5962 case 8900: return ((char *) HT_08900
); break;
5963 case 9000: return ((char *) HT_09000
); break;
5964 case 9100: return ((char *) HT_09100
); break;
5965 case 9200: return ((char *) HT_09200
); break;
5966 case 9300: return ((char *) HT_09300
); break;
5967 case 9400: return ((char *) HT_09400
); break;
5968 case 9500: return ((char *) HT_09500
); break;
5969 case 9600: return ((char *) HT_09600
); break;
5970 case 9700: return ((char *) HT_09700
); break;
5971 case 9710: return ((char *) HT_09710
); break;
5972 case 9720: return ((char *) HT_09720
); break;
5973 case 9800: return ((char *) HT_09800
); break;
5974 case 9810: return ((char *) HT_09810
); break;
5975 case 9820: return ((char *) HT_09820
); break;
5976 case 9900: return ((char *) HT_09900
); break;
5977 case 10000: return ((char *) HT_10000
); break;
5978 case 10100: return ((char *) HT_10100
); break;
5979 case 10200: return ((char *) HT_10200
); break;
5980 case 10300: return ((char *) HT_10300
); break;
5981 case 10400: return ((char *) HT_10400
); break;
5982 case 10410: return ((char *) HT_10410
); break;
5983 case 10420: return ((char *) HT_10420
); break;
5984 case 10500: return ((char *) HT_10500
); break;
5985 case 10600: return ((char *) HT_10600
); break;
5986 case 10700: return ((char *) HT_10700
); break;
5987 case 10800: return ((char *) HT_10800
); break;
5988 case 10900: return ((char *) HT_10900
); break;
5989 case 11000: return ((char *) HT_11000
); break;
5990 case 11100: return ((char *) HT_11100
); break;
5991 case 11200: return ((char *) HT_11200
); break;
5992 case 11300: return ((char *) HT_11300
); break;
5993 case 11400: return ((char *) HT_11400
); break;
5994 case 11500: return ((char *) HT_11500
); break;
5995 case 11600: return ((char *) HT_11600
); break;
5996 case 11700: return ((char *) HT_11700
); break;
5997 case 11800: return ((char *) HT_11800
); break;
5998 case 11900: return ((char *) HT_11900
); break;
5999 case 12000: return ((char *) HT_12000
); break;
6000 case 12100: return ((char *) HT_12100
); break;
6001 case 12200: return ((char *) HT_12200
); break;
6002 case 12300: return ((char *) HT_12300
); break;
6003 case 12400: return ((char *) HT_12400
); break;
6004 case 12500: return ((char *) HT_12500
); break;
6005 case 12600: return ((char *) HT_12600
); break;
6006 case 12700: return ((char *) HT_12700
); break;
6007 case 12800: return ((char *) HT_12800
); break;
6008 case 12900: return ((char *) HT_12900
); break;
6009 case 13000: return ((char *) HT_13000
); break;
6010 case 13100: return ((char *) HT_13100
); break;
6011 case 13200: return ((char *) HT_13200
); break;
6012 case 13300: return ((char *) HT_13300
); break;
6013 case 13400: return ((char *) HT_13400
); break;
6014 case 13500: return ((char *) HT_13500
); break;
6015 case 13600: return ((char *) HT_13600
); break;
6016 case 13711: return ((char *) HT_13711
); break;
6017 case 13712: return ((char *) HT_13712
); break;
6018 case 13713: return ((char *) HT_13713
); break;
6019 case 13721: return ((char *) HT_13721
); break;
6020 case 13722: return ((char *) HT_13722
); break;
6021 case 13723: return ((char *) HT_13723
); break;
6022 case 13731: return ((char *) HT_13731
); break;
6023 case 13732: return ((char *) HT_13732
); break;
6024 case 13733: return ((char *) HT_13733
); break;
6025 case 13741: return ((char *) HT_13741
); break;
6026 case 13742: return ((char *) HT_13742
); break;
6027 case 13743: return ((char *) HT_13743
); break;
6028 case 13751: return ((char *) HT_13751
); break;
6029 case 13752: return ((char *) HT_13752
); break;
6030 case 13753: return ((char *) HT_13753
); break;
6031 case 13761: return ((char *) HT_13761
); break;
6032 case 13762: return ((char *) HT_13762
); break;
6033 case 13763: return ((char *) HT_13763
); break;
6034 case 13800: return ((char *) HT_13800
); break;
6037 return ((char *) "Unknown");
6040 char *strstatus (const uint devices_status
)
6042 switch (devices_status
)
6044 case STATUS_INIT
: return ((char *) ST_0000
); break;
6045 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6046 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6047 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6048 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6049 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6050 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6051 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6052 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6053 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6054 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6057 return ((char *) "Unknown");
6060 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6062 uint hash_type
= data
.hash_type
;
6063 uint hash_mode
= data
.hash_mode
;
6064 uint salt_type
= data
.salt_type
;
6065 uint opts_type
= data
.opts_type
;
6066 uint opti_type
= data
.opti_type
;
6067 uint dgst_size
= data
.dgst_size
;
6069 char *hashfile
= data
.hashfile
;
6073 uint digest_buf
[64] = { 0 };
6075 u64
*digest_buf64
= (u64
*) digest_buf
;
6077 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6079 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6081 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6087 case HASH_TYPE_DESCRYPT
:
6088 FP (digest_buf
[1], digest_buf
[0], tt
);
6091 case HASH_TYPE_DESRACF
:
6092 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6093 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6095 FP (digest_buf
[1], digest_buf
[0], tt
);
6099 FP (digest_buf
[1], digest_buf
[0], tt
);
6102 case HASH_TYPE_NETNTLM
:
6103 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6104 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6105 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6106 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6108 FP (digest_buf
[1], digest_buf
[0], tt
);
6109 FP (digest_buf
[3], digest_buf
[2], tt
);
6112 case HASH_TYPE_BSDICRYPT
:
6113 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6114 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6116 FP (digest_buf
[1], digest_buf
[0], tt
);
6121 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6126 digest_buf
[0] += MD4M_A
;
6127 digest_buf
[1] += MD4M_B
;
6128 digest_buf
[2] += MD4M_C
;
6129 digest_buf
[3] += MD4M_D
;
6133 digest_buf
[0] += MD5M_A
;
6134 digest_buf
[1] += MD5M_B
;
6135 digest_buf
[2] += MD5M_C
;
6136 digest_buf
[3] += MD5M_D
;
6139 case HASH_TYPE_SHA1
:
6140 digest_buf
[0] += SHA1M_A
;
6141 digest_buf
[1] += SHA1M_B
;
6142 digest_buf
[2] += SHA1M_C
;
6143 digest_buf
[3] += SHA1M_D
;
6144 digest_buf
[4] += SHA1M_E
;
6147 case HASH_TYPE_SHA256
:
6148 digest_buf
[0] += SHA256M_A
;
6149 digest_buf
[1] += SHA256M_B
;
6150 digest_buf
[2] += SHA256M_C
;
6151 digest_buf
[3] += SHA256M_D
;
6152 digest_buf
[4] += SHA256M_E
;
6153 digest_buf
[5] += SHA256M_F
;
6154 digest_buf
[6] += SHA256M_G
;
6155 digest_buf
[7] += SHA256M_H
;
6158 case HASH_TYPE_SHA384
:
6159 digest_buf64
[0] += SHA384M_A
;
6160 digest_buf64
[1] += SHA384M_B
;
6161 digest_buf64
[2] += SHA384M_C
;
6162 digest_buf64
[3] += SHA384M_D
;
6163 digest_buf64
[4] += SHA384M_E
;
6164 digest_buf64
[5] += SHA384M_F
;
6165 digest_buf64
[6] += 0;
6166 digest_buf64
[7] += 0;
6169 case HASH_TYPE_SHA512
:
6170 digest_buf64
[0] += SHA512M_A
;
6171 digest_buf64
[1] += SHA512M_B
;
6172 digest_buf64
[2] += SHA512M_C
;
6173 digest_buf64
[3] += SHA512M_D
;
6174 digest_buf64
[4] += SHA512M_E
;
6175 digest_buf64
[5] += SHA512M_F
;
6176 digest_buf64
[6] += SHA512M_G
;
6177 digest_buf64
[7] += SHA512M_H
;
6182 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6184 if (dgst_size
== DGST_SIZE_4_2
)
6186 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6188 else if (dgst_size
== DGST_SIZE_4_4
)
6190 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6192 else if (dgst_size
== DGST_SIZE_4_5
)
6194 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6196 else if (dgst_size
== DGST_SIZE_4_6
)
6198 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6200 else if (dgst_size
== DGST_SIZE_4_8
)
6202 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6204 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6206 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6208 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6210 else if (hash_type
== HASH_TYPE_SHA384
)
6212 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6214 else if (hash_type
== HASH_TYPE_SHA512
)
6216 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6218 else if (hash_type
== HASH_TYPE_GOST
)
6220 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6223 else if (dgst_size
== DGST_SIZE_4_64
)
6225 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6227 else if (dgst_size
== DGST_SIZE_8_25
)
6229 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6233 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6234 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6235 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6241 memset (&salt
, 0, sizeof (salt_t
));
6243 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6245 char *ptr
= (char *) salt
.salt_buf
;
6247 uint len
= salt
.salt_len
;
6249 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6255 case HASH_TYPE_NETNTLM
:
6257 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6258 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6260 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6266 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6268 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6276 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6278 uint max
= salt
.salt_len
/ 4;
6282 for (uint i
= 0; i
< max
; i
++)
6284 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6288 if (opts_type
& OPTS_TYPE_ST_HEX
)
6290 char tmp
[64] = { 0 };
6292 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6294 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6299 memcpy (ptr
, tmp
, len
);
6302 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6304 memset (ptr
+ len
, 0, memset_size
);
6306 salt
.salt_len
= len
;
6310 // some modes require special encoding
6313 uint out_buf_plain
[256] = { 0 };
6314 uint out_buf_salt
[256] = { 0 };
6316 char tmp_buf
[1024] = { 0 };
6318 char *ptr_plain
= (char *) out_buf_plain
;
6319 char *ptr_salt
= (char *) out_buf_salt
;
6321 if (hash_mode
== 22)
6323 char username
[30] = { 0 };
6325 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6327 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6329 u16
*ptr
= (u16
*) digest_buf
;
6331 tmp_buf
[ 0] = sig
[0];
6332 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6333 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6334 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6335 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6336 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6337 tmp_buf
[ 6] = sig
[1];
6338 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6339 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6340 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6341 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6342 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6343 tmp_buf
[12] = sig
[2];
6344 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6345 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6346 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6347 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6348 tmp_buf
[17] = sig
[3];
6349 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6350 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6351 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6352 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6353 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6354 tmp_buf
[23] = sig
[4];
6355 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6356 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6357 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6358 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6359 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6360 tmp_buf
[29] = sig
[5];
6362 snprintf (out_buf
, len
-1, "%s:%s",
6366 else if (hash_mode
== 23)
6368 // do not show the skyper part in output
6370 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6372 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6374 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6381 else if (hash_mode
== 101)
6383 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6385 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6386 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6387 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6388 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6389 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6391 memcpy (tmp_buf
, digest_buf
, 20);
6393 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6395 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6397 else if (hash_mode
== 111)
6399 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6401 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6402 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6403 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6404 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6405 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6407 memcpy (tmp_buf
, digest_buf
, 20);
6408 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6410 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6412 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6414 else if ((hash_mode
== 122) || (hash_mode
== 125))
6416 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6417 (char *) salt
.salt_buf
,
6424 else if (hash_mode
== 124)
6426 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6427 (char *) salt
.salt_buf
,
6434 else if (hash_mode
== 131)
6436 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6437 (char *) salt
.salt_buf
,
6445 else if (hash_mode
== 132)
6447 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6448 (char *) salt
.salt_buf
,
6455 else if (hash_mode
== 133)
6457 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6459 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6460 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6461 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6462 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6463 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6465 memcpy (tmp_buf
, digest_buf
, 20);
6467 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6469 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6471 else if (hash_mode
== 141)
6473 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6475 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6477 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6479 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6481 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6482 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6483 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6484 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6485 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6487 memcpy (tmp_buf
, digest_buf
, 20);
6489 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6493 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6495 else if (hash_mode
== 400)
6497 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6499 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6500 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6501 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6502 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6504 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6506 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6508 else if (hash_mode
== 500)
6510 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6512 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6513 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6514 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6515 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6517 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6519 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6521 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6525 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6528 else if (hash_mode
== 501)
6530 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6532 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6533 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6535 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6537 else if (hash_mode
== 1421)
6539 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6541 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6557 else if (hash_mode
== 1441)
6559 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6561 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6563 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6565 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6567 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6568 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6569 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6570 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6571 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6572 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6573 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6574 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6576 memcpy (tmp_buf
, digest_buf
, 32);
6578 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6582 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6584 else if (hash_mode
== 1500)
6586 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6587 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6588 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6589 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6590 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6592 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6594 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6596 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6597 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6599 memcpy (tmp_buf
, digest_buf
, 8);
6601 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6603 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6607 else if (hash_mode
== 1600)
6609 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6611 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6612 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6613 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6614 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6616 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6618 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6620 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6624 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6627 else if (hash_mode
== 1711)
6629 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6631 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6632 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6633 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6634 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6635 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6636 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6637 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6638 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6640 memcpy (tmp_buf
, digest_buf
, 64);
6641 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6643 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6645 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6647 else if (hash_mode
== 1722)
6649 uint
*ptr
= digest_buf
;
6651 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6652 (unsigned char *) salt
.salt_buf
,
6662 else if (hash_mode
== 1731)
6664 uint
*ptr
= digest_buf
;
6666 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6667 (unsigned char *) salt
.salt_buf
,
6677 else if (hash_mode
== 1800)
6681 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6682 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6683 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6684 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6685 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6686 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6687 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6688 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6690 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6692 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6694 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6698 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6701 else if (hash_mode
== 2100)
6705 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6707 salt
.salt_iter
+ 1);
6709 uint signature_len
= strlen (out_buf
);
6711 pos
+= signature_len
;
6712 len
-= signature_len
;
6714 char *salt_ptr
= (char *) salt
.salt_buf
;
6716 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6718 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6719 byte_swap_32 (digest_buf
[0]),
6720 byte_swap_32 (digest_buf
[1]),
6721 byte_swap_32 (digest_buf
[2]),
6722 byte_swap_32 (digest_buf
[3]));
6724 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6726 memcpy (tmp_buf
, digest_buf
, 16);
6728 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6730 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6731 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6732 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6733 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6735 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6736 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6737 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6738 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6740 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6741 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6742 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6743 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6745 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6746 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6747 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6748 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6750 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6751 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6752 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6753 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6757 else if (hash_mode
== 2500)
6759 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6761 wpa_t
*wpa
= &wpas
[salt_pos
];
6763 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6764 (char *) salt
.salt_buf
,
6778 else if (hash_mode
== 4400)
6780 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6781 byte_swap_32 (digest_buf
[0]),
6782 byte_swap_32 (digest_buf
[1]),
6783 byte_swap_32 (digest_buf
[2]),
6784 byte_swap_32 (digest_buf
[3]));
6786 else if (hash_mode
== 4700)
6788 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6789 byte_swap_32 (digest_buf
[0]),
6790 byte_swap_32 (digest_buf
[1]),
6791 byte_swap_32 (digest_buf
[2]),
6792 byte_swap_32 (digest_buf
[3]),
6793 byte_swap_32 (digest_buf
[4]));
6795 else if (hash_mode
== 4800)
6797 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6799 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6804 byte_swap_32 (salt
.salt_buf
[0]),
6805 byte_swap_32 (salt
.salt_buf
[1]),
6806 byte_swap_32 (salt
.salt_buf
[2]),
6807 byte_swap_32 (salt
.salt_buf
[3]),
6810 else if (hash_mode
== 4900)
6812 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6813 byte_swap_32 (digest_buf
[0]),
6814 byte_swap_32 (digest_buf
[1]),
6815 byte_swap_32 (digest_buf
[2]),
6816 byte_swap_32 (digest_buf
[3]),
6817 byte_swap_32 (digest_buf
[4]));
6819 else if (hash_mode
== 5100)
6821 snprintf (out_buf
, len
-1, "%08x%08x",
6825 else if (hash_mode
== 5200)
6827 snprintf (out_buf
, len
-1, "%s", hashfile
);
6829 else if (hash_mode
== 5300)
6831 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6833 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6835 int buf_len
= len
-1;
6839 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6841 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6843 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6845 snprintf (out_buf
, buf_len
, ":");
6851 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6859 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6861 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6863 if ((i
== 0) || (i
== 5))
6865 snprintf (out_buf
, buf_len
, ":");
6871 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6879 for (uint i
= 0; i
< 4; i
++)
6883 snprintf (out_buf
, buf_len
, ":");
6889 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6895 else if (hash_mode
== 5400)
6897 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6899 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6901 int buf_len
= len
-1;
6905 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6907 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6909 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6911 snprintf (out_buf
, buf_len
, ":");
6917 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6925 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6927 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6929 if ((i
== 0) || (i
== 5))
6931 snprintf (out_buf
, buf_len
, ":");
6937 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6945 for (uint i
= 0; i
< 5; i
++)
6949 snprintf (out_buf
, buf_len
, ":");
6955 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6961 else if (hash_mode
== 5500)
6963 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6965 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6967 char user_buf
[64] = { 0 };
6968 char domain_buf
[64] = { 0 };
6969 char srvchall_buf
[1024] = { 0 };
6970 char clichall_buf
[1024] = { 0 };
6972 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6974 char *ptr
= (char *) netntlm
->userdomain_buf
;
6976 user_buf
[i
] = ptr
[j
];
6979 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6981 char *ptr
= (char *) netntlm
->userdomain_buf
;
6983 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6986 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6988 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6990 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6993 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6995 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6997 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7000 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7008 byte_swap_32 (salt
.salt_buf_pc
[0]),
7009 byte_swap_32 (salt
.salt_buf_pc
[1]),
7012 else if (hash_mode
== 5600)
7014 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7016 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7018 char user_buf
[64] = { 0 };
7019 char domain_buf
[64] = { 0 };
7020 char srvchall_buf
[1024] = { 0 };
7021 char clichall_buf
[1024] = { 0 };
7023 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7025 char *ptr
= (char *) netntlm
->userdomain_buf
;
7027 user_buf
[i
] = ptr
[j
];
7030 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7032 char *ptr
= (char *) netntlm
->userdomain_buf
;
7034 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7037 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7039 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7041 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7044 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7046 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7048 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7051 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7061 else if (hash_mode
== 5700)
7063 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7065 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7066 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7067 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7068 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7069 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7070 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7071 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7072 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7074 memcpy (tmp_buf
, digest_buf
, 32);
7076 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7080 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7082 else if (hash_mode
== 5800)
7084 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7085 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7086 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7087 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7088 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7090 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7097 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7099 snprintf (out_buf
, len
-1, "%s", hashfile
);
7101 else if (hash_mode
== 6300)
7103 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7105 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7106 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7107 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7108 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7110 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7112 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7114 else if (hash_mode
== 6400)
7116 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7118 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7120 else if (hash_mode
== 6500)
7122 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7124 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7126 else if (hash_mode
== 6600)
7128 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7130 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7132 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7133 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7135 uint buf_len
= len
- 1;
7137 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7140 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7142 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7147 else if (hash_mode
== 6700)
7149 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7151 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7153 else if (hash_mode
== 6800)
7155 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7157 else if (hash_mode
== 7100)
7159 uint
*ptr
= digest_buf
;
7161 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7163 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7165 uint esalt
[8] = { 0 };
7167 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7168 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7169 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7170 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7171 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7172 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7173 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7174 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7176 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",
7177 SIGNATURE_SHA512OSX
,
7179 esalt
[ 0], esalt
[ 1],
7180 esalt
[ 2], esalt
[ 3],
7181 esalt
[ 4], esalt
[ 5],
7182 esalt
[ 6], esalt
[ 7],
7190 ptr
[15], ptr
[14]);
7192 else if (hash_mode
== 7200)
7194 uint
*ptr
= digest_buf
;
7196 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7198 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7202 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7204 len_used
= strlen (out_buf
);
7206 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7208 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7210 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7213 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",
7221 ptr
[15], ptr
[14]);
7223 else if (hash_mode
== 7300)
7225 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7227 rakp_t
*rakp
= &rakps
[salt_pos
];
7229 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7231 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7234 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7241 else if (hash_mode
== 7400)
7243 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7245 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7246 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7247 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7248 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7249 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7250 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7251 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7252 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7254 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7256 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7258 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7262 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7265 else if (hash_mode
== 7500)
7267 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7269 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7271 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7272 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7274 char data
[128] = { 0 };
7276 char *ptr_data
= data
;
7278 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7280 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7283 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7285 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7290 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7292 (char *) krb5pa
->user
,
7293 (char *) krb5pa
->realm
,
7294 (char *) krb5pa
->salt
,
7297 else if (hash_mode
== 7700)
7299 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7300 (char *) salt
.salt_buf
,
7304 else if (hash_mode
== 7800)
7306 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7307 (char *) salt
.salt_buf
,
7314 else if (hash_mode
== 7900)
7316 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7320 char *tmp
= (char *) salt
.salt_buf_pc
;
7322 ptr_plain
[42] = tmp
[0];
7328 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7330 else if (hash_mode
== 8000)
7332 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7333 (unsigned char *) salt
.salt_buf
,
7343 else if (hash_mode
== 8100)
7345 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7346 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7348 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7349 (unsigned char *) salt
.salt_buf
,
7356 else if (hash_mode
== 8200)
7358 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7360 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7362 char data_buf
[4096] = { 0 };
7364 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7366 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7369 data_buf
[cloudkey
->data_len
* 2] = 0;
7371 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7372 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7373 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7374 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7375 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7376 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7377 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7378 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7380 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7381 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7382 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7383 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7385 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7401 else if (hash_mode
== 8300)
7403 char digest_buf_c
[34] = { 0 };
7405 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7406 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7407 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7408 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7409 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7411 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7413 digest_buf_c
[32] = 0;
7417 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7419 char domain_buf_c
[33] = { 0 };
7421 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7423 for (uint i
= 0; i
< salt_pc_len
; i
++)
7425 const char next
= domain_buf_c
[i
];
7427 domain_buf_c
[i
] = '.';
7432 domain_buf_c
[salt_pc_len
] = 0;
7436 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7438 else if (hash_mode
== 8500)
7440 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7442 else if (hash_mode
== 2612)
7444 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7446 (char *) salt
.salt_buf
,
7452 else if (hash_mode
== 3711)
7454 char *salt_ptr
= (char *) salt
.salt_buf
;
7456 salt_ptr
[salt
.salt_len
- 1] = 0;
7458 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7459 SIGNATURE_MEDIAWIKI_B
,
7466 else if (hash_mode
== 8800)
7468 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7470 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7472 char tmp
[3073] = { 0 };
7474 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7476 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7481 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7482 SIGNATURE_ANDROIDFDE
,
7483 byte_swap_32 (salt
.salt_buf
[0]),
7484 byte_swap_32 (salt
.salt_buf
[1]),
7485 byte_swap_32 (salt
.salt_buf
[2]),
7486 byte_swap_32 (salt
.salt_buf
[3]),
7487 byte_swap_32 (digest_buf
[0]),
7488 byte_swap_32 (digest_buf
[1]),
7489 byte_swap_32 (digest_buf
[2]),
7490 byte_swap_32 (digest_buf
[3]),
7493 else if (hash_mode
== 8900)
7495 uint N
= salt
.scrypt_N
;
7496 uint r
= salt
.scrypt_r
;
7497 uint p
= salt
.scrypt_p
;
7499 char base64_salt
[32] = { 0 };
7501 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7503 memset (tmp_buf
, 0, 46);
7505 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7506 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7507 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7508 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7509 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7510 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7511 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7512 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7513 digest_buf
[8] = 0; // needed for base64_encode ()
7515 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7517 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7525 else if (hash_mode
== 9000)
7527 snprintf (out_buf
, len
-1, "%s", hashfile
);
7529 else if (hash_mode
== 9200)
7533 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7535 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7537 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7541 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7542 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7543 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7544 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7545 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7546 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7547 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7548 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7549 digest_buf
[8] = 0; // needed for base64_encode ()
7551 char tmp_buf
[64] = { 0 };
7553 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7554 tmp_buf
[43] = 0; // cut it here
7558 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7560 else if (hash_mode
== 9300)
7562 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7563 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7564 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7565 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7566 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7567 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7568 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7569 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7570 digest_buf
[8] = 0; // needed for base64_encode ()
7572 char tmp_buf
[64] = { 0 };
7574 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7575 tmp_buf
[43] = 0; // cut it here
7577 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7579 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7581 else if (hash_mode
== 9400)
7583 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7585 office2007_t
*office2007
= &office2007s
[salt_pos
];
7587 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7588 SIGNATURE_OFFICE2007
,
7591 office2007
->keySize
,
7597 office2007
->encryptedVerifier
[0],
7598 office2007
->encryptedVerifier
[1],
7599 office2007
->encryptedVerifier
[2],
7600 office2007
->encryptedVerifier
[3],
7601 office2007
->encryptedVerifierHash
[0],
7602 office2007
->encryptedVerifierHash
[1],
7603 office2007
->encryptedVerifierHash
[2],
7604 office2007
->encryptedVerifierHash
[3],
7605 office2007
->encryptedVerifierHash
[4]);
7607 else if (hash_mode
== 9500)
7609 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7611 office2010_t
*office2010
= &office2010s
[salt_pos
];
7613 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,
7619 office2010
->encryptedVerifier
[0],
7620 office2010
->encryptedVerifier
[1],
7621 office2010
->encryptedVerifier
[2],
7622 office2010
->encryptedVerifier
[3],
7623 office2010
->encryptedVerifierHash
[0],
7624 office2010
->encryptedVerifierHash
[1],
7625 office2010
->encryptedVerifierHash
[2],
7626 office2010
->encryptedVerifierHash
[3],
7627 office2010
->encryptedVerifierHash
[4],
7628 office2010
->encryptedVerifierHash
[5],
7629 office2010
->encryptedVerifierHash
[6],
7630 office2010
->encryptedVerifierHash
[7]);
7632 else if (hash_mode
== 9600)
7634 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7636 office2013_t
*office2013
= &office2013s
[salt_pos
];
7638 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,
7644 office2013
->encryptedVerifier
[0],
7645 office2013
->encryptedVerifier
[1],
7646 office2013
->encryptedVerifier
[2],
7647 office2013
->encryptedVerifier
[3],
7648 office2013
->encryptedVerifierHash
[0],
7649 office2013
->encryptedVerifierHash
[1],
7650 office2013
->encryptedVerifierHash
[2],
7651 office2013
->encryptedVerifierHash
[3],
7652 office2013
->encryptedVerifierHash
[4],
7653 office2013
->encryptedVerifierHash
[5],
7654 office2013
->encryptedVerifierHash
[6],
7655 office2013
->encryptedVerifierHash
[7]);
7657 else if (hash_mode
== 9700)
7659 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7661 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7663 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7664 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7665 byte_swap_32 (salt
.salt_buf
[0]),
7666 byte_swap_32 (salt
.salt_buf
[1]),
7667 byte_swap_32 (salt
.salt_buf
[2]),
7668 byte_swap_32 (salt
.salt_buf
[3]),
7669 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7670 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7671 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7672 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7673 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7674 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7675 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7676 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7678 else if (hash_mode
== 9710)
7680 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7682 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7684 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7685 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7686 byte_swap_32 (salt
.salt_buf
[0]),
7687 byte_swap_32 (salt
.salt_buf
[1]),
7688 byte_swap_32 (salt
.salt_buf
[2]),
7689 byte_swap_32 (salt
.salt_buf
[3]),
7690 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7691 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7692 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7693 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7694 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7695 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7696 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7697 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7699 else if (hash_mode
== 9720)
7701 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7703 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7705 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7707 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7708 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7709 byte_swap_32 (salt
.salt_buf
[0]),
7710 byte_swap_32 (salt
.salt_buf
[1]),
7711 byte_swap_32 (salt
.salt_buf
[2]),
7712 byte_swap_32 (salt
.salt_buf
[3]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7727 else if (hash_mode
== 9800)
7729 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7731 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7733 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7734 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7739 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7740 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7741 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7742 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7743 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7744 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7745 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7746 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7747 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7749 else if (hash_mode
== 9810)
7751 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7753 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7755 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7756 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7761 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7762 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7763 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7764 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7765 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7766 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7767 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7768 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7769 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7771 else if (hash_mode
== 9820)
7773 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7775 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7777 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7779 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7780 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7792 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7793 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7800 else if (hash_mode
== 10000)
7804 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7806 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7808 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7812 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7813 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7814 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7815 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7816 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7817 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7818 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7819 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7820 digest_buf
[8] = 0; // needed for base64_encode ()
7822 char tmp_buf
[64] = { 0 };
7824 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7828 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7830 else if (hash_mode
== 10100)
7832 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7837 byte_swap_32 (salt
.salt_buf
[0]),
7838 byte_swap_32 (salt
.salt_buf
[1]),
7839 byte_swap_32 (salt
.salt_buf
[2]),
7840 byte_swap_32 (salt
.salt_buf
[3]));
7842 else if (hash_mode
== 10200)
7844 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7846 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7850 char challenge
[100] = { 0 };
7852 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7856 char tmp_buf
[100] = { 0 };
7858 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7859 (char *) cram_md5
->user
,
7865 char response
[100] = { 0 };
7867 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7869 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7871 else if (hash_mode
== 10300)
7873 char tmp_buf
[100] = { 0 };
7875 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7876 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7878 uint tmp_len
= 20 + salt
.salt_len
;
7882 char base64_encoded
[100] = { 0 };
7884 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7886 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7888 else if (hash_mode
== 10400)
7890 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7892 pdf_t
*pdf
= &pdfs
[salt_pos
];
7894 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",
7902 byte_swap_32 (pdf
->id_buf
[0]),
7903 byte_swap_32 (pdf
->id_buf
[1]),
7904 byte_swap_32 (pdf
->id_buf
[2]),
7905 byte_swap_32 (pdf
->id_buf
[3]),
7907 byte_swap_32 (pdf
->u_buf
[0]),
7908 byte_swap_32 (pdf
->u_buf
[1]),
7909 byte_swap_32 (pdf
->u_buf
[2]),
7910 byte_swap_32 (pdf
->u_buf
[3]),
7911 byte_swap_32 (pdf
->u_buf
[4]),
7912 byte_swap_32 (pdf
->u_buf
[5]),
7913 byte_swap_32 (pdf
->u_buf
[6]),
7914 byte_swap_32 (pdf
->u_buf
[7]),
7916 byte_swap_32 (pdf
->o_buf
[0]),
7917 byte_swap_32 (pdf
->o_buf
[1]),
7918 byte_swap_32 (pdf
->o_buf
[2]),
7919 byte_swap_32 (pdf
->o_buf
[3]),
7920 byte_swap_32 (pdf
->o_buf
[4]),
7921 byte_swap_32 (pdf
->o_buf
[5]),
7922 byte_swap_32 (pdf
->o_buf
[6]),
7923 byte_swap_32 (pdf
->o_buf
[7])
7926 else if (hash_mode
== 10410)
7928 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7930 pdf_t
*pdf
= &pdfs
[salt_pos
];
7932 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",
7940 byte_swap_32 (pdf
->id_buf
[0]),
7941 byte_swap_32 (pdf
->id_buf
[1]),
7942 byte_swap_32 (pdf
->id_buf
[2]),
7943 byte_swap_32 (pdf
->id_buf
[3]),
7945 byte_swap_32 (pdf
->u_buf
[0]),
7946 byte_swap_32 (pdf
->u_buf
[1]),
7947 byte_swap_32 (pdf
->u_buf
[2]),
7948 byte_swap_32 (pdf
->u_buf
[3]),
7949 byte_swap_32 (pdf
->u_buf
[4]),
7950 byte_swap_32 (pdf
->u_buf
[5]),
7951 byte_swap_32 (pdf
->u_buf
[6]),
7952 byte_swap_32 (pdf
->u_buf
[7]),
7954 byte_swap_32 (pdf
->o_buf
[0]),
7955 byte_swap_32 (pdf
->o_buf
[1]),
7956 byte_swap_32 (pdf
->o_buf
[2]),
7957 byte_swap_32 (pdf
->o_buf
[3]),
7958 byte_swap_32 (pdf
->o_buf
[4]),
7959 byte_swap_32 (pdf
->o_buf
[5]),
7960 byte_swap_32 (pdf
->o_buf
[6]),
7961 byte_swap_32 (pdf
->o_buf
[7])
7964 else if (hash_mode
== 10420)
7966 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7968 pdf_t
*pdf
= &pdfs
[salt_pos
];
7970 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7972 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",
7980 byte_swap_32 (pdf
->id_buf
[0]),
7981 byte_swap_32 (pdf
->id_buf
[1]),
7982 byte_swap_32 (pdf
->id_buf
[2]),
7983 byte_swap_32 (pdf
->id_buf
[3]),
7985 byte_swap_32 (pdf
->u_buf
[0]),
7986 byte_swap_32 (pdf
->u_buf
[1]),
7987 byte_swap_32 (pdf
->u_buf
[2]),
7988 byte_swap_32 (pdf
->u_buf
[3]),
7989 byte_swap_32 (pdf
->u_buf
[4]),
7990 byte_swap_32 (pdf
->u_buf
[5]),
7991 byte_swap_32 (pdf
->u_buf
[6]),
7992 byte_swap_32 (pdf
->u_buf
[7]),
7994 byte_swap_32 (pdf
->o_buf
[0]),
7995 byte_swap_32 (pdf
->o_buf
[1]),
7996 byte_swap_32 (pdf
->o_buf
[2]),
7997 byte_swap_32 (pdf
->o_buf
[3]),
7998 byte_swap_32 (pdf
->o_buf
[4]),
7999 byte_swap_32 (pdf
->o_buf
[5]),
8000 byte_swap_32 (pdf
->o_buf
[6]),
8001 byte_swap_32 (pdf
->o_buf
[7]),
8009 else if (hash_mode
== 10500)
8011 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8013 pdf_t
*pdf
= &pdfs
[salt_pos
];
8015 if (pdf
->id_len
== 32)
8017 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",
8025 byte_swap_32 (pdf
->id_buf
[0]),
8026 byte_swap_32 (pdf
->id_buf
[1]),
8027 byte_swap_32 (pdf
->id_buf
[2]),
8028 byte_swap_32 (pdf
->id_buf
[3]),
8029 byte_swap_32 (pdf
->id_buf
[4]),
8030 byte_swap_32 (pdf
->id_buf
[5]),
8031 byte_swap_32 (pdf
->id_buf
[6]),
8032 byte_swap_32 (pdf
->id_buf
[7]),
8034 byte_swap_32 (pdf
->u_buf
[0]),
8035 byte_swap_32 (pdf
->u_buf
[1]),
8036 byte_swap_32 (pdf
->u_buf
[2]),
8037 byte_swap_32 (pdf
->u_buf
[3]),
8038 byte_swap_32 (pdf
->u_buf
[4]),
8039 byte_swap_32 (pdf
->u_buf
[5]),
8040 byte_swap_32 (pdf
->u_buf
[6]),
8041 byte_swap_32 (pdf
->u_buf
[7]),
8043 byte_swap_32 (pdf
->o_buf
[0]),
8044 byte_swap_32 (pdf
->o_buf
[1]),
8045 byte_swap_32 (pdf
->o_buf
[2]),
8046 byte_swap_32 (pdf
->o_buf
[3]),
8047 byte_swap_32 (pdf
->o_buf
[4]),
8048 byte_swap_32 (pdf
->o_buf
[5]),
8049 byte_swap_32 (pdf
->o_buf
[6]),
8050 byte_swap_32 (pdf
->o_buf
[7])
8055 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",
8063 byte_swap_32 (pdf
->id_buf
[0]),
8064 byte_swap_32 (pdf
->id_buf
[1]),
8065 byte_swap_32 (pdf
->id_buf
[2]),
8066 byte_swap_32 (pdf
->id_buf
[3]),
8068 byte_swap_32 (pdf
->u_buf
[0]),
8069 byte_swap_32 (pdf
->u_buf
[1]),
8070 byte_swap_32 (pdf
->u_buf
[2]),
8071 byte_swap_32 (pdf
->u_buf
[3]),
8072 byte_swap_32 (pdf
->u_buf
[4]),
8073 byte_swap_32 (pdf
->u_buf
[5]),
8074 byte_swap_32 (pdf
->u_buf
[6]),
8075 byte_swap_32 (pdf
->u_buf
[7]),
8077 byte_swap_32 (pdf
->o_buf
[0]),
8078 byte_swap_32 (pdf
->o_buf
[1]),
8079 byte_swap_32 (pdf
->o_buf
[2]),
8080 byte_swap_32 (pdf
->o_buf
[3]),
8081 byte_swap_32 (pdf
->o_buf
[4]),
8082 byte_swap_32 (pdf
->o_buf
[5]),
8083 byte_swap_32 (pdf
->o_buf
[6]),
8084 byte_swap_32 (pdf
->o_buf
[7])
8088 else if (hash_mode
== 10600)
8090 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8092 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8093 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8095 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8097 else if (hash_mode
== 10700)
8099 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8101 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8102 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8104 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8106 else if (hash_mode
== 10900)
8108 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8110 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8111 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8113 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8115 else if (hash_mode
== 11100)
8117 u32 salt_challenge
= salt
.salt_buf
[0];
8119 salt_challenge
= byte_swap_32 (salt_challenge
);
8121 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8123 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8124 SIGNATURE_POSTGRESQL_AUTH
,
8132 else if (hash_mode
== 11200)
8134 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8135 SIGNATURE_MYSQL_AUTH
,
8136 (unsigned char *) salt
.salt_buf
,
8143 else if (hash_mode
== 11300)
8145 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8147 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8149 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8150 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8151 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8153 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8154 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8155 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8157 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8159 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8161 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8164 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8166 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8168 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8171 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8173 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8175 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8178 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8179 SIGNATURE_BITCOIN_WALLET
,
8183 (unsigned char *) salt
.salt_buf
,
8191 free (cry_master_buf
);
8193 free (public_key_buf
);
8195 else if (hash_mode
== 11400)
8197 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8199 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8200 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8202 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8204 else if (hash_mode
== 11600)
8206 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8208 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8210 const uint data_len
= seven_zip
->data_len
;
8212 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8214 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8216 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8218 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8221 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8222 SIGNATURE_SEVEN_ZIP
,
8226 (char *) seven_zip
->salt_buf
,
8228 seven_zip
->iv_buf
[0],
8229 seven_zip
->iv_buf
[1],
8230 seven_zip
->iv_buf
[2],
8231 seven_zip
->iv_buf
[3],
8233 seven_zip
->data_len
,
8234 seven_zip
->unpack_size
,
8239 else if (hash_mode
== 11700)
8241 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8251 else if (hash_mode
== 11800)
8253 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8271 else if (hash_mode
== 11900)
8273 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8275 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8276 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8278 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8280 else if (hash_mode
== 12000)
8282 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8284 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8285 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8287 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8289 else if (hash_mode
== 12100)
8291 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8293 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8294 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8296 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8298 else if (hash_mode
== 12200)
8300 uint
*ptr_digest
= digest_buf
;
8301 uint
*ptr_salt
= salt
.salt_buf
;
8303 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8310 else if (hash_mode
== 12300)
8312 uint
*ptr_digest
= digest_buf
;
8313 uint
*ptr_salt
= salt
.salt_buf
;
8315 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",
8316 ptr_digest
[ 0], ptr_digest
[ 1],
8317 ptr_digest
[ 2], ptr_digest
[ 3],
8318 ptr_digest
[ 4], ptr_digest
[ 5],
8319 ptr_digest
[ 6], ptr_digest
[ 7],
8320 ptr_digest
[ 8], ptr_digest
[ 9],
8321 ptr_digest
[10], ptr_digest
[11],
8322 ptr_digest
[12], ptr_digest
[13],
8323 ptr_digest
[14], ptr_digest
[15],
8329 else if (hash_mode
== 12400)
8331 // encode iteration count
8333 char salt_iter
[5] = { 0 };
8335 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8336 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8337 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8338 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8343 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8344 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8345 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8346 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8351 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8353 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8354 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8356 memcpy (tmp_buf
, digest_buf
, 8);
8358 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8362 // fill the resulting buffer
8364 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8366 else if (hash_mode
== 12500)
8368 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8370 byte_swap_32 (salt
.salt_buf
[0]),
8371 byte_swap_32 (salt
.salt_buf
[1]),
8377 else if (hash_mode
== 12600)
8379 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8380 digest_buf
[0] + salt
.salt_buf_pc
[0],
8381 digest_buf
[1] + salt
.salt_buf_pc
[1],
8382 digest_buf
[2] + salt
.salt_buf_pc
[2],
8383 digest_buf
[3] + salt
.salt_buf_pc
[3],
8384 digest_buf
[4] + salt
.salt_buf_pc
[4],
8385 digest_buf
[5] + salt
.salt_buf_pc
[5],
8386 digest_buf
[6] + salt
.salt_buf_pc
[6],
8387 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8389 else if (hash_mode
== 12700)
8391 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8393 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8394 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8396 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8398 else if (hash_mode
== 12800)
8400 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8402 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",
8415 byte_swap_32 (digest_buf
[0]),
8416 byte_swap_32 (digest_buf
[1]),
8417 byte_swap_32 (digest_buf
[2]),
8418 byte_swap_32 (digest_buf
[3]),
8419 byte_swap_32 (digest_buf
[4]),
8420 byte_swap_32 (digest_buf
[5]),
8421 byte_swap_32 (digest_buf
[6]),
8422 byte_swap_32 (digest_buf
[7])
8425 else if (hash_mode
== 12900)
8427 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",
8436 byte_swap_32 (digest_buf
[0]),
8437 byte_swap_32 (digest_buf
[1]),
8438 byte_swap_32 (digest_buf
[2]),
8439 byte_swap_32 (digest_buf
[3]),
8440 byte_swap_32 (digest_buf
[4]),
8441 byte_swap_32 (digest_buf
[5]),
8442 byte_swap_32 (digest_buf
[6]),
8443 byte_swap_32 (digest_buf
[7]),
8450 else if (hash_mode
== 13000)
8452 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8454 rar5_t
*rar5
= &rar5s
[salt_pos
];
8456 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8466 byte_swap_32 (digest_buf
[0]),
8467 byte_swap_32 (digest_buf
[1])
8470 else if (hash_mode
== 13100)
8472 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8474 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8476 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8477 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8479 char data
[2560 * 4 * 2] = { 0 };
8481 char *ptr_data
= data
;
8483 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8484 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8489 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8490 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8492 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8494 (char *) krb5tgs
->account_info
,
8498 else if (hash_mode
== 13200)
8500 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8514 else if (hash_mode
== 13300)
8516 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8517 SIGNATURE_AXCRYPT_SHA1
,
8523 else if (hash_mode
== 13400)
8525 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8527 keepass_t
*keepass
= &keepasss
[salt_pos
];
8529 u32 version
= (u32
) keepass
->version
;
8530 u32 rounds
= salt
.salt_iter
;
8531 u32 algorithm
= (u32
) keepass
->algorithm
;
8532 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8534 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8535 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8536 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8537 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8538 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8540 /* specific to version 1 */
8544 /* specific to version 2 */
8545 u32 expected_bytes_len
;
8546 u32
*ptr_expected_bytes
;
8548 u32 final_random_seed_len
;
8549 u32 transf_random_seed_len
;
8551 u32 contents_hash_len
;
8553 transf_random_seed_len
= 8;
8555 contents_hash_len
= 8;
8556 final_random_seed_len
= 8;
8559 final_random_seed_len
= 4;
8561 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8567 char *ptr_data
= out_buf
;
8569 ptr_data
+= strlen(out_buf
);
8574 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8575 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8580 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8581 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8586 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8587 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8594 contents_len
= (u32
) keepass
->contents_len
;
8595 ptr_contents
= (u32
*) keepass
->contents
;
8597 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8598 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8610 char ptr_contents_len
[10] = { 0 };
8612 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8614 sprintf (ptr_data
, "%d", contents_len
);
8616 ptr_data
+= strlen(ptr_contents_len
);
8621 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8622 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8624 else if (version
== 2)
8626 expected_bytes_len
= 8;
8627 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8629 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8630 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8635 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8636 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8650 sprintf (ptr_data
, "%d", keyfile_len
);
8657 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8658 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8661 else if (hash_mode
== 13500)
8663 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8665 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8667 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8669 char pstoken_tmp
[1024 + 1] = { 0 };
8671 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8673 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8675 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8678 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8686 else if (hash_mode
== 13600)
8688 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8690 zip2_t
*zip2
= &zip2s
[salt_pos
];
8692 const u32 salt_len
= zip2
->salt_len
;
8694 char salt_tmp
[32 + 1] = { 0 };
8696 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8698 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8700 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8703 const u32 data_len
= zip2
->data_len
;
8705 char data_tmp
[8192 + 1] = { 0 };
8707 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8709 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8711 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8714 const u32 auth_len
= zip2
->auth_len
;
8716 char auth_tmp
[20 + 1] = { 0 };
8718 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8720 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8722 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8725 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8726 SIGNATURE_ZIP2_START
,
8732 zip2
->compress_length
,
8735 SIGNATURE_ZIP2_STOP
);
8737 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8739 snprintf (out_buf
, len
-1, "%s", hashfile
);
8741 else if (hash_mode
== 13800)
8743 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8745 win8phone_t
*esalt
= &esalts
[salt_pos
];
8747 char buf
[256 + 1] = { 0 };
8749 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8751 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8754 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8767 if (hash_type
== HASH_TYPE_MD4
)
8769 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8775 else if (hash_type
== HASH_TYPE_MD5
)
8777 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8783 else if (hash_type
== HASH_TYPE_SHA1
)
8785 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8792 else if (hash_type
== HASH_TYPE_SHA256
)
8794 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8804 else if (hash_type
== HASH_TYPE_SHA384
)
8806 uint
*ptr
= digest_buf
;
8808 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8816 else if (hash_type
== HASH_TYPE_SHA512
)
8818 uint
*ptr
= digest_buf
;
8820 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8830 else if (hash_type
== HASH_TYPE_LM
)
8832 snprintf (out_buf
, len
-1, "%08x%08x",
8836 else if (hash_type
== HASH_TYPE_ORACLEH
)
8838 snprintf (out_buf
, len
-1, "%08X%08X",
8842 else if (hash_type
== HASH_TYPE_BCRYPT
)
8844 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8845 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8847 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8849 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8851 else if (hash_type
== HASH_TYPE_KECCAK
)
8853 uint
*ptr
= digest_buf
;
8855 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",
8883 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8885 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8887 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8894 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8896 digest_buf
[ 0] = digest_buf
[ 0];
8897 digest_buf
[ 1] = digest_buf
[ 1];
8898 digest_buf
[ 2] = digest_buf
[ 2];
8899 digest_buf
[ 3] = digest_buf
[ 3];
8900 digest_buf
[ 4] = digest_buf
[ 4];
8901 digest_buf
[ 5] = digest_buf
[ 5];
8902 digest_buf
[ 6] = digest_buf
[ 6];
8903 digest_buf
[ 7] = digest_buf
[ 7];
8904 digest_buf
[ 8] = digest_buf
[ 8];
8905 digest_buf
[ 9] = digest_buf
[ 9];
8906 digest_buf
[10] = digest_buf
[10];
8907 digest_buf
[11] = digest_buf
[11];
8908 digest_buf
[12] = digest_buf
[12];
8909 digest_buf
[13] = digest_buf
[13];
8910 digest_buf
[14] = digest_buf
[14];
8911 digest_buf
[15] = digest_buf
[15];
8913 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8931 else if (hash_type
== HASH_TYPE_GOST
)
8933 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8943 else if (hash_type
== HASH_TYPE_MYSQL
)
8945 snprintf (out_buf
, len
-1, "%08x%08x",
8949 else if (hash_type
== HASH_TYPE_LOTUS5
)
8951 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8957 else if (hash_type
== HASH_TYPE_LOTUS6
)
8959 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8960 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8961 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8962 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8964 char buf
[16] = { 0 };
8966 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8967 memcpy (buf
+ 5, digest_buf
, 9);
8971 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8973 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8976 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8978 else if (hash_type
== HASH_TYPE_LOTUS8
)
8980 char buf
[52] = { 0 };
8984 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8990 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8994 buf
[26] = salt
.salt_buf_pc
[0];
8995 buf
[27] = salt
.salt_buf_pc
[1];
8999 memcpy (buf
+ 28, digest_buf
, 8);
9001 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9005 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9007 else if (hash_type
== HASH_TYPE_CRC32
)
9009 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9013 if (salt_type
== SALT_TYPE_INTERN
)
9015 size_t pos
= strlen (out_buf
);
9017 out_buf
[pos
] = data
.separator
;
9019 char *ptr
= (char *) salt
.salt_buf
;
9021 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9023 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9027 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9029 memset (hccap
, 0, sizeof (hccap_t
));
9031 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9033 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9035 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9036 wpa_t
*wpa
= &wpas
[salt_pos
];
9038 hccap
->keyver
= wpa
->keyver
;
9040 hccap
->eapol_size
= wpa
->eapol_size
;
9042 if (wpa
->keyver
!= 1)
9044 uint eapol_tmp
[64] = { 0 };
9046 for (uint i
= 0; i
< 64; i
++)
9048 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9051 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9055 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9058 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9059 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9060 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9061 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9063 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9065 uint dgst_size
= data
.dgst_size
;
9067 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9069 if (wpa
->keyver
!= 1)
9071 uint digest_tmp
[4] = { 0 };
9073 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9074 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9075 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9076 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9078 memcpy (hccap
->keymic
, digest_tmp
, 16);
9082 memcpy (hccap
->keymic
, digest_ptr
, 16);
9086 void SuspendThreads ()
9088 if (data
.devices_status
== STATUS_RUNNING
)
9090 hc_timer_set (&data
.timer_paused
);
9092 data
.devices_status
= STATUS_PAUSED
;
9094 log_info ("Paused");
9098 void ResumeThreads ()
9100 if (data
.devices_status
== STATUS_PAUSED
)
9104 hc_timer_get (data
.timer_paused
, ms_paused
);
9106 data
.ms_paused
+= ms_paused
;
9108 data
.devices_status
= STATUS_RUNNING
;
9110 log_info ("Resumed");
9116 if (data
.devices_status
!= STATUS_RUNNING
) return;
9118 data
.devices_status
= STATUS_BYPASS
;
9120 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9123 void stop_at_checkpoint ()
9125 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9127 if (data
.devices_status
!= STATUS_RUNNING
) return;
9130 // this feature only makes sense if --restore-disable was not specified
9132 if (data
.restore_disable
== 1)
9134 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9139 // check if monitoring of Restore Point updates should be enabled or disabled
9141 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9143 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9145 // save the current restore point value
9147 data
.checkpoint_cur_words
= get_lowest_words_done ();
9149 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9153 data
.devices_status
= STATUS_RUNNING
;
9155 // reset the global value for checkpoint checks
9157 data
.checkpoint_cur_words
= 0;
9159 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9165 if (data
.devices_status
== STATUS_INIT
) return;
9166 if (data
.devices_status
== STATUS_STARTING
) return;
9168 data
.devices_status
= STATUS_ABORTED
;
9173 if (data
.devices_status
== STATUS_INIT
) return;
9174 if (data
.devices_status
== STATUS_STARTING
) return;
9176 data
.devices_status
= STATUS_QUIT
;
9179 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9181 FILE *fp
= fopen (kernel_file
, "rb");
9187 memset (&st
, 0, sizeof (st
));
9189 stat (kernel_file
, &st
);
9191 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9193 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9195 if (num_read
!= (size_t) st
.st_size
)
9197 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9204 buf
[st
.st_size
] = 0;
9206 for (int i
= 0; i
< num_devices
; i
++)
9208 kernel_lengths
[i
] = (size_t) st
.st_size
;
9210 kernel_sources
[i
] = buf
;
9215 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9223 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9225 if (binary_size
> 0)
9227 FILE *fp
= fopen (dst
, "wb");
9230 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9241 restore_data_t
*init_restore (int argc
, char **argv
)
9243 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9245 if (data
.restore_disable
== 0)
9247 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9251 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9255 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9264 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9266 int pidbin_len
= -1;
9269 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9271 FILE *fd
= fopen (pidbin
, "rb");
9275 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9277 pidbin
[pidbin_len
] = 0;
9281 char *argv0_r
= strrchr (argv
[0], '/');
9283 char *pidbin_r
= strrchr (pidbin
, '/');
9285 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9287 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9289 if (strcmp (argv0_r
, pidbin_r
) == 0)
9291 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9298 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9300 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9302 int pidbin2_len
= -1;
9304 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9305 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9307 pidbin
[pidbin_len
] = 0;
9308 pidbin2
[pidbin2_len
] = 0;
9312 if (strcmp (pidbin
, pidbin2
) == 0)
9314 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9327 if (rd
->version_bin
< RESTORE_MIN
)
9329 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9336 memset (rd
, 0, sizeof (restore_data_t
));
9338 rd
->version_bin
= VERSION_BIN
;
9341 rd
->pid
= getpid ();
9343 rd
->pid
= GetCurrentProcessId ();
9346 if (getcwd (rd
->cwd
, 255) == NULL
)
9359 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9361 FILE *fp
= fopen (eff_restore_file
, "rb");
9365 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9370 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9372 log_error ("ERROR: cannot read %s", eff_restore_file
);
9377 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9379 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9381 for (uint i
= 0; i
< rd
->argc
; i
++)
9383 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9385 log_error ("ERROR: cannot read %s", eff_restore_file
);
9390 size_t len
= strlen (buf
);
9392 if (len
) buf
[len
- 1] = 0;
9394 rd
->argv
[i
] = mystrdup (buf
);
9401 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9403 if (chdir (rd
->cwd
))
9405 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9406 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9407 " https://github.com/philsmd/analyze_hc_restore\n"
9408 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9414 u64
get_lowest_words_done ()
9418 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9420 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9422 if (device_param
->skipped
) continue;
9424 const u64 words_done
= device_param
->words_done
;
9426 if (words_done
< words_cur
) words_cur
= words_done
;
9429 // It's possible that a device's workload isn't finished right after a restore-case.
9430 // In that case, this function would return 0 and overwrite the real restore point
9431 // There's also data.words_cur which is set to rd->words_cur but it changes while
9432 // the attack is running therefore we should stick to rd->words_cur.
9433 // Note that -s influences rd->words_cur we should keep a close look on that.
9435 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9440 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9442 u64 words_cur
= get_lowest_words_done ();
9444 rd
->words_cur
= words_cur
;
9446 FILE *fp
= fopen (new_restore_file
, "wb");
9450 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9455 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9457 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9462 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9464 for (uint i
= 0; i
< rd
->argc
; i
++)
9466 fprintf (fp
, "%s", rd
->argv
[i
]);
9472 fsync (fileno (fp
));
9477 void cycle_restore ()
9479 const char *eff_restore_file
= data
.eff_restore_file
;
9480 const char *new_restore_file
= data
.new_restore_file
;
9482 restore_data_t
*rd
= data
.rd
;
9484 write_restore (new_restore_file
, rd
);
9488 memset (&st
, 0, sizeof(st
));
9490 if (stat (eff_restore_file
, &st
) == 0)
9492 if (unlink (eff_restore_file
))
9494 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9498 if (rename (new_restore_file
, eff_restore_file
))
9500 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9504 void check_checkpoint ()
9506 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9508 u64 words_cur
= get_lowest_words_done ();
9510 if (words_cur
!= data
.checkpoint_cur_words
)
9520 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9524 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9526 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9528 myfree (alias
->device_name
);
9529 myfree (alias
->alias_name
);
9532 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9534 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9536 myfree (entry
->device_name
);
9539 myfree (tuning_db
->alias_buf
);
9540 myfree (tuning_db
->entry_buf
);
9545 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9547 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9549 int num_lines
= count_lines (fp
);
9551 // a bit over-allocated
9553 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9554 tuning_db
->alias_cnt
= 0;
9556 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9557 tuning_db
->entry_cnt
= 0;
9562 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9564 FILE *fp
= fopen (tuning_db_file
, "rb");
9568 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9573 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9579 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9583 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9585 if (line_buf
== NULL
) break;
9589 const int line_len
= in_superchop (line_buf
);
9591 if (line_len
== 0) continue;
9593 if (line_buf
[0] == '#') continue;
9597 char *token_ptr
[7] = { NULL
};
9601 char *next
= strtok (line_buf
, "\t ");
9603 token_ptr
[token_cnt
] = next
;
9607 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9609 token_ptr
[token_cnt
] = next
;
9616 char *device_name
= token_ptr
[0];
9617 char *alias_name
= token_ptr
[1];
9619 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9621 alias
->device_name
= mystrdup (device_name
);
9622 alias
->alias_name
= mystrdup (alias_name
);
9624 tuning_db
->alias_cnt
++;
9626 else if (token_cnt
== 6)
9628 if ((token_ptr
[1][0] != '0') &&
9629 (token_ptr
[1][0] != '1') &&
9630 (token_ptr
[1][0] != '3') &&
9631 (token_ptr
[1][0] != '*'))
9633 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9638 if ((token_ptr
[3][0] != '1') &&
9639 (token_ptr
[3][0] != '2') &&
9640 (token_ptr
[3][0] != '4') &&
9641 (token_ptr
[3][0] != '8') &&
9642 (token_ptr
[3][0] != 'N'))
9644 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9649 char *device_name
= token_ptr
[0];
9651 int attack_mode
= -1;
9653 int vector_width
= -1;
9654 int kernel_accel
= -1;
9655 int kernel_loops
= -1;
9657 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9658 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9659 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9661 if (token_ptr
[4][0] != 'A')
9663 kernel_accel
= atoi (token_ptr
[4]);
9665 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9667 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9677 if (token_ptr
[5][0] != 'A')
9679 kernel_loops
= atoi (token_ptr
[5]);
9681 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9683 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9693 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9695 entry
->device_name
= mystrdup (device_name
);
9696 entry
->attack_mode
= attack_mode
;
9697 entry
->hash_type
= hash_type
;
9698 entry
->vector_width
= vector_width
;
9699 entry
->kernel_accel
= kernel_accel
;
9700 entry
->kernel_loops
= kernel_loops
;
9702 tuning_db
->entry_cnt
++;
9706 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9716 // todo: print loaded 'cnt' message
9718 // sort the database
9720 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9721 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9726 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9728 static tuning_db_entry_t s
;
9730 // first we need to convert all spaces in the device_name to underscore
9732 char *device_name_nospace
= strdup (device_param
->device_name
);
9734 int device_name_length
= strlen (device_name_nospace
);
9738 for (i
= 0; i
< device_name_length
; i
++)
9740 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9743 // find out if there's an alias configured
9745 tuning_db_alias_t a
;
9747 a
.device_name
= device_name_nospace
;
9749 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
);
9751 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9753 // attack-mode 6 and 7 are attack-mode 1 basically
9755 if (attack_mode
== 6) attack_mode
= 1;
9756 if (attack_mode
== 7) attack_mode
= 1;
9758 // bsearch is not ideal but fast enough
9760 s
.device_name
= device_name_nospace
;
9761 s
.attack_mode
= attack_mode
;
9762 s
.hash_type
= hash_type
;
9764 tuning_db_entry_t
*entry
= NULL
;
9766 // this will produce all 2^3 combinations required
9768 for (i
= 0; i
< 8; i
++)
9770 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9771 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9772 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9774 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9776 if (entry
!= NULL
) break;
9778 // in non-wildcard mode do some additional checks:
9782 // in case we have an alias-name
9784 if (alias_name
!= NULL
)
9786 s
.device_name
= alias_name
;
9788 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9790 if (entry
!= NULL
) break;
9793 // or by device type
9795 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9797 s
.device_name
= "DEVICE_TYPE_CPU";
9799 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9801 s
.device_name
= "DEVICE_TYPE_GPU";
9803 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9805 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9808 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9810 if (entry
!= NULL
) break;
9814 // free converted device_name
9816 myfree (device_name_nospace
);
9825 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9827 u8 tmp
[256] = { 0 };
9829 if (salt_len
> sizeof (tmp
))
9834 memcpy (tmp
, in
, salt_len
);
9836 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9838 if ((salt_len
% 2) == 0)
9840 u32 new_salt_len
= salt_len
/ 2;
9842 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9847 tmp
[i
] = hex_convert (p1
) << 0;
9848 tmp
[i
] |= hex_convert (p0
) << 4;
9851 salt_len
= new_salt_len
;
9858 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9860 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9863 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9865 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9869 u32
*tmp_uint
= (u32
*) tmp
;
9871 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9872 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9873 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9874 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9875 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9876 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9877 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9878 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9879 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9880 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9882 salt_len
= salt_len
* 2;
9890 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9892 lowercase (tmp
, salt_len
);
9895 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9897 uppercase (tmp
, salt_len
);
9902 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9907 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9912 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9914 u32
*tmp_uint
= (uint
*) tmp
;
9920 for (u32 i
= 0; i
< max
; i
++)
9922 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9925 // Important: we may need to increase the length of memcpy since
9926 // we don't want to "loose" some swapped bytes (could happen if
9927 // they do not perfectly fit in the 4-byte blocks)
9928 // Memcpy does always copy the bytes in the BE order, but since
9929 // we swapped them, some important bytes could be in positions
9930 // we normally skip with the original len
9932 if (len
% 4) len
+= 4 - (len
% 4);
9935 memcpy (out
, tmp
, len
);
9940 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9942 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9944 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9946 u32
*digest
= (u32
*) hash_buf
->digest
;
9948 salt_t
*salt
= hash_buf
->salt
;
9950 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9952 char *iter_pos
= input_buf
+ 4;
9954 salt
->salt_iter
= 1 << atoi (iter_pos
);
9956 char *salt_pos
= strchr (iter_pos
, '$');
9958 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9964 salt
->salt_len
= salt_len
;
9966 u8 tmp_buf
[100] = { 0 };
9968 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9970 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9972 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9974 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9975 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9976 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9977 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9979 char *hash_pos
= salt_pos
+ 22;
9981 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9983 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9985 memcpy (digest
, tmp_buf
, 24);
9987 digest
[0] = byte_swap_32 (digest
[0]);
9988 digest
[1] = byte_swap_32 (digest
[1]);
9989 digest
[2] = byte_swap_32 (digest
[2]);
9990 digest
[3] = byte_swap_32 (digest
[3]);
9991 digest
[4] = byte_swap_32 (digest
[4]);
9992 digest
[5] = byte_swap_32 (digest
[5]);
9994 digest
[5] &= ~0xff; // its just 23 not 24 !
9999 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10001 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10003 u32
*digest
= (u32
*) hash_buf
->digest
;
10005 u8 tmp_buf
[100] = { 0 };
10007 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10009 memcpy (digest
, tmp_buf
, 32);
10011 digest
[0] = byte_swap_32 (digest
[0]);
10012 digest
[1] = byte_swap_32 (digest
[1]);
10013 digest
[2] = byte_swap_32 (digest
[2]);
10014 digest
[3] = byte_swap_32 (digest
[3]);
10015 digest
[4] = byte_swap_32 (digest
[4]);
10016 digest
[5] = byte_swap_32 (digest
[5]);
10017 digest
[6] = byte_swap_32 (digest
[6]);
10018 digest
[7] = byte_swap_32 (digest
[7]);
10020 digest
[0] -= SHA256M_A
;
10021 digest
[1] -= SHA256M_B
;
10022 digest
[2] -= SHA256M_C
;
10023 digest
[3] -= SHA256M_D
;
10024 digest
[4] -= SHA256M_E
;
10025 digest
[5] -= SHA256M_F
;
10026 digest
[6] -= SHA256M_G
;
10027 digest
[7] -= SHA256M_H
;
10029 return (PARSER_OK
);
10032 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10034 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10036 u32
*digest
= (u32
*) hash_buf
->digest
;
10038 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10039 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10041 digest
[0] = byte_swap_32 (digest
[0]);
10042 digest
[1] = byte_swap_32 (digest
[1]);
10046 IP (digest
[0], digest
[1], tt
);
10048 digest
[0] = digest
[0];
10049 digest
[1] = digest
[1];
10053 return (PARSER_OK
);
10056 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10058 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10060 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10062 u32
*digest
= (u32
*) hash_buf
->digest
;
10064 salt_t
*salt
= hash_buf
->salt
;
10066 char *hash_pos
= input_buf
+ 10;
10068 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10069 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10070 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10071 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10072 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10074 digest
[0] -= SHA1M_A
;
10075 digest
[1] -= SHA1M_B
;
10076 digest
[2] -= SHA1M_C
;
10077 digest
[3] -= SHA1M_D
;
10078 digest
[4] -= SHA1M_E
;
10080 uint salt_len
= 10;
10082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10084 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10088 salt
->salt_len
= salt_len
;
10090 return (PARSER_OK
);
10093 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10095 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10097 u32
*digest
= (u32
*) hash_buf
->digest
;
10099 salt_t
*salt
= hash_buf
->salt
;
10101 char *hash_pos
= input_buf
+ 8;
10103 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10104 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10105 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10106 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10107 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10109 digest
[0] -= SHA1M_A
;
10110 digest
[1] -= SHA1M_B
;
10111 digest
[2] -= SHA1M_C
;
10112 digest
[3] -= SHA1M_D
;
10113 digest
[4] -= SHA1M_E
;
10117 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10119 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10121 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10123 salt
->salt_len
= salt_len
;
10125 return (PARSER_OK
);
10128 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10130 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10132 u64
*digest
= (u64
*) hash_buf
->digest
;
10134 salt_t
*salt
= hash_buf
->salt
;
10136 char *hash_pos
= input_buf
+ 8;
10138 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10139 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10140 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10141 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10142 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10143 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10144 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10145 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10147 digest
[0] -= SHA512M_A
;
10148 digest
[1] -= SHA512M_B
;
10149 digest
[2] -= SHA512M_C
;
10150 digest
[3] -= SHA512M_D
;
10151 digest
[4] -= SHA512M_E
;
10152 digest
[5] -= SHA512M_F
;
10153 digest
[6] -= SHA512M_G
;
10154 digest
[7] -= SHA512M_H
;
10158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10160 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10164 salt
->salt_len
= salt_len
;
10166 return (PARSER_OK
);
10169 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10171 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10173 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10177 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10180 u32
*digest
= (u32
*) hash_buf
->digest
;
10182 salt_t
*salt
= hash_buf
->salt
;
10184 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10185 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10186 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10187 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10189 digest
[0] = byte_swap_32 (digest
[0]);
10190 digest
[1] = byte_swap_32 (digest
[1]);
10191 digest
[2] = byte_swap_32 (digest
[2]);
10192 digest
[3] = byte_swap_32 (digest
[3]);
10194 digest
[0] -= MD5M_A
;
10195 digest
[1] -= MD5M_B
;
10196 digest
[2] -= MD5M_C
;
10197 digest
[3] -= MD5M_D
;
10199 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10201 uint salt_len
= input_len
- 32 - 1;
10203 char *salt_buf
= input_buf
+ 32 + 1;
10205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10211 salt
->salt_len
= salt_len
;
10213 return (PARSER_OK
);
10216 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10218 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10220 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10224 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10229 char clean_input_buf
[32] = { 0 };
10231 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10232 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10234 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10238 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10244 clean_input_buf
[k
] = input_buf
[i
];
10252 u32
*digest
= (u32
*) hash_buf
->digest
;
10254 salt_t
*salt
= hash_buf
->salt
;
10256 u32 a
, b
, c
, d
, e
, f
;
10258 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10259 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10260 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10261 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10262 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10263 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10265 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10266 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10268 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10269 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10270 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10271 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10272 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10273 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10275 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10276 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10278 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10279 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10280 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10281 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10282 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10283 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10285 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10286 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10288 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10289 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10290 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10291 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10292 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10293 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10295 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10296 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10298 digest
[0] = byte_swap_32 (digest
[0]);
10299 digest
[1] = byte_swap_32 (digest
[1]);
10300 digest
[2] = byte_swap_32 (digest
[2]);
10301 digest
[3] = byte_swap_32 (digest
[3]);
10303 digest
[0] -= MD5M_A
;
10304 digest
[1] -= MD5M_B
;
10305 digest
[2] -= MD5M_C
;
10306 digest
[3] -= MD5M_D
;
10308 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10310 uint salt_len
= input_len
- 30 - 1;
10312 char *salt_buf
= input_buf
+ 30 + 1;
10314 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10316 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10318 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10319 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10321 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10323 salt
->salt_len
= salt_len
;
10325 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10327 salt
->salt_len
+= 22;
10329 return (PARSER_OK
);
10332 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10334 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10336 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10340 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10343 u32
*digest
= (u32
*) hash_buf
->digest
;
10345 salt_t
*salt
= hash_buf
->salt
;
10347 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10348 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10349 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10350 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10351 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10353 digest
[0] -= SHA1M_A
;
10354 digest
[1] -= SHA1M_B
;
10355 digest
[2] -= SHA1M_C
;
10356 digest
[3] -= SHA1M_D
;
10357 digest
[4] -= SHA1M_E
;
10359 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10361 uint salt_len
= input_len
- 40 - 1;
10363 char *salt_buf
= input_buf
+ 40 + 1;
10365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10371 salt
->salt_len
= salt_len
;
10373 return (PARSER_OK
);
10376 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10378 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10380 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10384 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10387 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10389 char *iter_pos
= input_buf
+ 6;
10391 salt_t
*salt
= hash_buf
->salt
;
10393 uint iter
= atoi (iter_pos
);
10397 iter
= ROUNDS_DCC2
;
10400 salt
->salt_iter
= iter
- 1;
10402 char *salt_pos
= strchr (iter_pos
, '#');
10404 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10408 char *digest_pos
= strchr (salt_pos
, '#');
10410 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10414 uint salt_len
= digest_pos
- salt_pos
- 1;
10416 u32
*digest
= (u32
*) hash_buf
->digest
;
10418 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10419 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10420 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10421 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10427 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10429 salt
->salt_len
= salt_len
;
10431 return (PARSER_OK
);
10434 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10436 u32
*digest
= (u32
*) hash_buf
->digest
;
10438 salt_t
*salt
= hash_buf
->salt
;
10440 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10444 memcpy (&in
, input_buf
, input_len
);
10446 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10448 memcpy (digest
, in
.keymic
, 16);
10451 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10452 The phrase "Pairwise key expansion"
10453 Access Point Address (referred to as Authenticator Address AA)
10454 Supplicant Address (referred to as Supplicant Address SA)
10455 Access Point Nonce (referred to as Authenticator Anonce)
10456 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10459 uint salt_len
= strlen (in
.essid
);
10463 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10465 return (PARSER_SALT_LENGTH
);
10468 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10470 salt
->salt_len
= salt_len
;
10472 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10474 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10476 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10478 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10480 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10481 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10485 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10486 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10489 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10491 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10492 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10496 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10497 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10500 for (int i
= 0; i
< 25; i
++)
10502 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10505 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10506 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10507 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10508 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10510 wpa
->keyver
= in
.keyver
;
10512 if (wpa
->keyver
> 255)
10514 log_info ("ATTENTION!");
10515 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10516 log_info (" This could be due to a recent aircrack-ng bug.");
10517 log_info (" The key version was automatically reset to a reasonable value.");
10520 wpa
->keyver
&= 0xff;
10523 wpa
->eapol_size
= in
.eapol_size
;
10525 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10527 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10529 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10531 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10533 if (wpa
->keyver
== 1)
10539 digest
[0] = byte_swap_32 (digest
[0]);
10540 digest
[1] = byte_swap_32 (digest
[1]);
10541 digest
[2] = byte_swap_32 (digest
[2]);
10542 digest
[3] = byte_swap_32 (digest
[3]);
10544 for (int i
= 0; i
< 64; i
++)
10546 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10550 uint32_t *p0
= (uint32_t *) in
.essid
;
10554 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10555 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10557 salt
->salt_buf
[10] = c0
;
10558 salt
->salt_buf
[11] = c1
;
10560 return (PARSER_OK
);
10563 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10565 u32
*digest
= (u32
*) hash_buf
->digest
;
10567 salt_t
*salt
= hash_buf
->salt
;
10569 if (input_len
== 0)
10571 log_error ("Password Safe v2 container not specified");
10576 FILE *fp
= fopen (input_buf
, "rb");
10580 log_error ("%s: %s", input_buf
, strerror (errno
));
10587 memset (&buf
, 0, sizeof (psafe2_hdr
));
10589 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10593 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10595 salt
->salt_buf
[0] = buf
.random
[0];
10596 salt
->salt_buf
[1] = buf
.random
[1];
10598 salt
->salt_len
= 8;
10599 salt
->salt_iter
= 1000;
10601 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10602 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10603 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10604 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10605 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10607 return (PARSER_OK
);
10610 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10612 u32
*digest
= (u32
*) hash_buf
->digest
;
10614 salt_t
*salt
= hash_buf
->salt
;
10616 if (input_len
== 0)
10618 log_error (".psafe3 not specified");
10623 FILE *fp
= fopen (input_buf
, "rb");
10627 log_error ("%s: %s", input_buf
, strerror (errno
));
10634 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10638 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10640 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10642 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10644 salt
->salt_iter
= in
.iterations
+ 1;
10646 salt
->salt_buf
[0] = in
.salt_buf
[0];
10647 salt
->salt_buf
[1] = in
.salt_buf
[1];
10648 salt
->salt_buf
[2] = in
.salt_buf
[2];
10649 salt
->salt_buf
[3] = in
.salt_buf
[3];
10650 salt
->salt_buf
[4] = in
.salt_buf
[4];
10651 salt
->salt_buf
[5] = in
.salt_buf
[5];
10652 salt
->salt_buf
[6] = in
.salt_buf
[6];
10653 salt
->salt_buf
[7] = in
.salt_buf
[7];
10655 salt
->salt_len
= 32;
10657 digest
[0] = in
.hash_buf
[0];
10658 digest
[1] = in
.hash_buf
[1];
10659 digest
[2] = in
.hash_buf
[2];
10660 digest
[3] = in
.hash_buf
[3];
10661 digest
[4] = in
.hash_buf
[4];
10662 digest
[5] = in
.hash_buf
[5];
10663 digest
[6] = in
.hash_buf
[6];
10664 digest
[7] = in
.hash_buf
[7];
10666 digest
[0] = byte_swap_32 (digest
[0]);
10667 digest
[1] = byte_swap_32 (digest
[1]);
10668 digest
[2] = byte_swap_32 (digest
[2]);
10669 digest
[3] = byte_swap_32 (digest
[3]);
10670 digest
[4] = byte_swap_32 (digest
[4]);
10671 digest
[5] = byte_swap_32 (digest
[5]);
10672 digest
[6] = byte_swap_32 (digest
[6]);
10673 digest
[7] = byte_swap_32 (digest
[7]);
10675 return (PARSER_OK
);
10678 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10680 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10682 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10684 u32
*digest
= (u32
*) hash_buf
->digest
;
10686 salt_t
*salt
= hash_buf
->salt
;
10688 char *iter_pos
= input_buf
+ 3;
10690 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10692 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10694 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10696 salt
->salt_iter
= salt_iter
;
10698 char *salt_pos
= iter_pos
+ 1;
10702 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10704 salt
->salt_len
= salt_len
;
10706 char *hash_pos
= salt_pos
+ salt_len
;
10708 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10710 return (PARSER_OK
);
10713 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10715 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10717 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10719 u32
*digest
= (u32
*) hash_buf
->digest
;
10721 salt_t
*salt
= hash_buf
->salt
;
10723 char *salt_pos
= input_buf
+ 3;
10725 uint iterations_len
= 0;
10727 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10731 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10733 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10734 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10738 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10742 iterations_len
+= 8;
10746 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10749 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10751 char *hash_pos
= strchr (salt_pos
, '$');
10753 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10755 uint salt_len
= hash_pos
- salt_pos
;
10757 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10759 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10761 salt
->salt_len
= salt_len
;
10765 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10767 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10769 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10771 return (PARSER_OK
);
10774 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10776 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10778 u32
*digest
= (u32
*) hash_buf
->digest
;
10780 salt_t
*salt
= hash_buf
->salt
;
10782 char *salt_pos
= input_buf
+ 6;
10784 uint iterations_len
= 0;
10786 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10790 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10792 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10793 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10797 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10801 iterations_len
+= 8;
10805 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10808 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10810 char *hash_pos
= strchr (salt_pos
, '$');
10812 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10814 uint salt_len
= hash_pos
- salt_pos
;
10816 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10818 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10820 salt
->salt_len
= salt_len
;
10824 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10826 return (PARSER_OK
);
10829 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10831 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10833 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10835 u32
*digest
= (u32
*) hash_buf
->digest
;
10837 salt_t
*salt
= hash_buf
->salt
;
10839 char *salt_pos
= input_buf
+ 14;
10841 char *hash_pos
= strchr (salt_pos
, '*');
10843 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10847 uint salt_len
= hash_pos
- salt_pos
- 1;
10849 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10851 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10853 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10855 salt
->salt_len
= salt_len
;
10857 u8 tmp_buf
[100] = { 0 };
10859 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10861 memcpy (digest
, tmp_buf
, 20);
10863 digest
[0] = byte_swap_32 (digest
[0]);
10864 digest
[1] = byte_swap_32 (digest
[1]);
10865 digest
[2] = byte_swap_32 (digest
[2]);
10866 digest
[3] = byte_swap_32 (digest
[3]);
10867 digest
[4] = byte_swap_32 (digest
[4]);
10869 digest
[0] -= SHA1M_A
;
10870 digest
[1] -= SHA1M_B
;
10871 digest
[2] -= SHA1M_C
;
10872 digest
[3] -= SHA1M_D
;
10873 digest
[4] -= SHA1M_E
;
10875 return (PARSER_OK
);
10878 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10880 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10882 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10884 if (c12
& 3) return (PARSER_HASH_VALUE
);
10886 u32
*digest
= (u32
*) hash_buf
->digest
;
10888 salt_t
*salt
= hash_buf
->salt
;
10890 // for ascii_digest
10891 salt
->salt_sign
[0] = input_buf
[0];
10892 salt
->salt_sign
[1] = input_buf
[1];
10894 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10895 | itoa64_to_int (input_buf
[1]) << 6;
10897 salt
->salt_len
= 2;
10899 u8 tmp_buf
[100] = { 0 };
10901 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10903 memcpy (digest
, tmp_buf
, 8);
10907 IP (digest
[0], digest
[1], tt
);
10912 return (PARSER_OK
);
10915 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10917 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10919 u32
*digest
= (u32
*) hash_buf
->digest
;
10921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10926 digest
[0] = byte_swap_32 (digest
[0]);
10927 digest
[1] = byte_swap_32 (digest
[1]);
10928 digest
[2] = byte_swap_32 (digest
[2]);
10929 digest
[3] = byte_swap_32 (digest
[3]);
10931 digest
[0] -= MD4M_A
;
10932 digest
[1] -= MD4M_B
;
10933 digest
[2] -= MD4M_C
;
10934 digest
[3] -= MD4M_D
;
10936 return (PARSER_OK
);
10939 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10941 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10943 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10947 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10950 u32
*digest
= (u32
*) hash_buf
->digest
;
10952 salt_t
*salt
= hash_buf
->salt
;
10954 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10955 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10956 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10957 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10959 digest
[0] = byte_swap_32 (digest
[0]);
10960 digest
[1] = byte_swap_32 (digest
[1]);
10961 digest
[2] = byte_swap_32 (digest
[2]);
10962 digest
[3] = byte_swap_32 (digest
[3]);
10964 digest
[0] -= MD4M_A
;
10965 digest
[1] -= MD4M_B
;
10966 digest
[2] -= MD4M_C
;
10967 digest
[3] -= MD4M_D
;
10969 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10971 uint salt_len
= input_len
- 32 - 1;
10973 char *salt_buf
= input_buf
+ 32 + 1;
10975 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10977 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10979 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10981 salt
->salt_len
= salt_len
;
10983 return (PARSER_OK
);
10986 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10988 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10990 u32
*digest
= (u32
*) hash_buf
->digest
;
10992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10997 digest
[0] = byte_swap_32 (digest
[0]);
10998 digest
[1] = byte_swap_32 (digest
[1]);
10999 digest
[2] = byte_swap_32 (digest
[2]);
11000 digest
[3] = byte_swap_32 (digest
[3]);
11002 digest
[0] -= MD5M_A
;
11003 digest
[1] -= MD5M_B
;
11004 digest
[2] -= MD5M_C
;
11005 digest
[3] -= MD5M_D
;
11007 return (PARSER_OK
);
11010 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11012 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11014 u32
*digest
= (u32
*) hash_buf
->digest
;
11016 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11017 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11021 digest
[0] = byte_swap_32 (digest
[0]);
11022 digest
[1] = byte_swap_32 (digest
[1]);
11024 return (PARSER_OK
);
11027 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11029 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11031 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11035 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11038 u32
*digest
= (u32
*) hash_buf
->digest
;
11040 salt_t
*salt
= hash_buf
->salt
;
11042 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11043 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11044 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11045 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11047 digest
[0] = byte_swap_32 (digest
[0]);
11048 digest
[1] = byte_swap_32 (digest
[1]);
11049 digest
[2] = byte_swap_32 (digest
[2]);
11050 digest
[3] = byte_swap_32 (digest
[3]);
11052 digest
[0] -= MD5M_A
;
11053 digest
[1] -= MD5M_B
;
11054 digest
[2] -= MD5M_C
;
11055 digest
[3] -= MD5M_D
;
11057 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11059 uint salt_len
= input_len
- 32 - 1;
11061 char *salt_buf
= input_buf
+ 32 + 1;
11063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11065 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11067 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11069 salt
->salt_len
= salt_len
;
11071 return (PARSER_OK
);
11074 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11076 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11078 u32
*digest
= (u32
*) hash_buf
->digest
;
11080 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11081 | itoa64_to_int (input_buf
[ 1]) << 6
11082 | itoa64_to_int (input_buf
[ 2]) << 12
11083 | itoa64_to_int (input_buf
[ 3]) << 18;
11084 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11085 | itoa64_to_int (input_buf
[ 5]) << 6
11086 | itoa64_to_int (input_buf
[ 6]) << 12
11087 | itoa64_to_int (input_buf
[ 7]) << 18;
11088 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11089 | itoa64_to_int (input_buf
[ 9]) << 6
11090 | itoa64_to_int (input_buf
[10]) << 12
11091 | itoa64_to_int (input_buf
[11]) << 18;
11092 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11093 | itoa64_to_int (input_buf
[13]) << 6
11094 | itoa64_to_int (input_buf
[14]) << 12
11095 | itoa64_to_int (input_buf
[15]) << 18;
11097 digest
[0] -= MD5M_A
;
11098 digest
[1] -= MD5M_B
;
11099 digest
[2] -= MD5M_C
;
11100 digest
[3] -= MD5M_D
;
11102 digest
[0] &= 0x00ffffff;
11103 digest
[1] &= 0x00ffffff;
11104 digest
[2] &= 0x00ffffff;
11105 digest
[3] &= 0x00ffffff;
11107 return (PARSER_OK
);
11110 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11112 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11114 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11118 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11121 u32
*digest
= (u32
*) hash_buf
->digest
;
11123 salt_t
*salt
= hash_buf
->salt
;
11125 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11126 | itoa64_to_int (input_buf
[ 1]) << 6
11127 | itoa64_to_int (input_buf
[ 2]) << 12
11128 | itoa64_to_int (input_buf
[ 3]) << 18;
11129 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11130 | itoa64_to_int (input_buf
[ 5]) << 6
11131 | itoa64_to_int (input_buf
[ 6]) << 12
11132 | itoa64_to_int (input_buf
[ 7]) << 18;
11133 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11134 | itoa64_to_int (input_buf
[ 9]) << 6
11135 | itoa64_to_int (input_buf
[10]) << 12
11136 | itoa64_to_int (input_buf
[11]) << 18;
11137 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11138 | itoa64_to_int (input_buf
[13]) << 6
11139 | itoa64_to_int (input_buf
[14]) << 12
11140 | itoa64_to_int (input_buf
[15]) << 18;
11142 digest
[0] -= MD5M_A
;
11143 digest
[1] -= MD5M_B
;
11144 digest
[2] -= MD5M_C
;
11145 digest
[3] -= MD5M_D
;
11147 digest
[0] &= 0x00ffffff;
11148 digest
[1] &= 0x00ffffff;
11149 digest
[2] &= 0x00ffffff;
11150 digest
[3] &= 0x00ffffff;
11152 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11154 uint salt_len
= input_len
- 16 - 1;
11156 char *salt_buf
= input_buf
+ 16 + 1;
11158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11164 salt
->salt_len
= salt_len
;
11166 return (PARSER_OK
);
11169 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11171 key
[0] = (nthash
[0] >> 0);
11172 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11173 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11174 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11175 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11176 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11177 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11178 key
[7] = (nthash
[6] << 1);
11190 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11192 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11194 u32
*digest
= (u32
*) hash_buf
->digest
;
11196 salt_t
*salt
= hash_buf
->salt
;
11198 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11204 char *user_pos
= input_buf
;
11206 char *unused_pos
= strchr (user_pos
, ':');
11208 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11210 uint user_len
= unused_pos
- user_pos
;
11212 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11216 char *domain_pos
= strchr (unused_pos
, ':');
11218 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11220 uint unused_len
= domain_pos
- unused_pos
;
11222 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11226 char *srvchall_pos
= strchr (domain_pos
, ':');
11228 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11230 uint domain_len
= srvchall_pos
- domain_pos
;
11232 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11236 char *hash_pos
= strchr (srvchall_pos
, ':');
11238 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11240 uint srvchall_len
= hash_pos
- srvchall_pos
;
11242 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11246 char *clichall_pos
= strchr (hash_pos
, ':');
11248 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11250 uint hash_len
= clichall_pos
- hash_pos
;
11252 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11256 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11258 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11261 * store some data for later use
11264 netntlm
->user_len
= user_len
* 2;
11265 netntlm
->domain_len
= domain_len
* 2;
11266 netntlm
->srvchall_len
= srvchall_len
/ 2;
11267 netntlm
->clichall_len
= clichall_len
/ 2;
11269 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11270 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11273 * handle username and domainname
11276 for (uint i
= 0; i
< user_len
; i
++)
11278 *userdomain_ptr
++ = user_pos
[i
];
11279 *userdomain_ptr
++ = 0;
11282 for (uint i
= 0; i
< domain_len
; i
++)
11284 *userdomain_ptr
++ = domain_pos
[i
];
11285 *userdomain_ptr
++ = 0;
11289 * handle server challenge encoding
11292 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11294 const char p0
= srvchall_pos
[i
+ 0];
11295 const char p1
= srvchall_pos
[i
+ 1];
11297 *chall_ptr
++ = hex_convert (p1
) << 0
11298 | hex_convert (p0
) << 4;
11302 * handle client challenge encoding
11305 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11307 const char p0
= clichall_pos
[i
+ 0];
11308 const char p1
= clichall_pos
[i
+ 1];
11310 *chall_ptr
++ = hex_convert (p1
) << 0
11311 | hex_convert (p0
) << 4;
11318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11320 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11324 salt
->salt_len
= salt_len
;
11326 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11327 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11328 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11329 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11331 digest
[0] = byte_swap_32 (digest
[0]);
11332 digest
[1] = byte_swap_32 (digest
[1]);
11333 digest
[2] = byte_swap_32 (digest
[2]);
11334 digest
[3] = byte_swap_32 (digest
[3]);
11336 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11338 uint digest_tmp
[2] = { 0 };
11340 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11341 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11343 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11344 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11346 /* special case 2: ESS */
11348 if (srvchall_len
== 48)
11350 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11352 uint w
[16] = { 0 };
11354 w
[ 0] = netntlm
->chall_buf
[6];
11355 w
[ 1] = netntlm
->chall_buf
[7];
11356 w
[ 2] = netntlm
->chall_buf
[0];
11357 w
[ 3] = netntlm
->chall_buf
[1];
11361 uint dgst
[4] = { 0 };
11370 salt
->salt_buf
[0] = dgst
[0];
11371 salt
->salt_buf
[1] = dgst
[1];
11375 /* precompute netntlmv1 exploit start */
11377 for (uint i
= 0; i
< 0x10000; i
++)
11379 uint key_md4
[2] = { i
, 0 };
11380 uint key_des
[2] = { 0, 0 };
11382 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11384 uint Kc
[16] = { 0 };
11385 uint Kd
[16] = { 0 };
11387 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11389 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11391 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11393 if (data3
[0] != digest_tmp
[0]) continue;
11394 if (data3
[1] != digest_tmp
[1]) continue;
11396 salt
->salt_buf
[2] = i
;
11398 salt
->salt_len
= 24;
11403 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11404 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11406 /* precompute netntlmv1 exploit stop */
11410 IP (digest
[0], digest
[1], tt
);
11411 IP (digest
[2], digest
[3], tt
);
11413 digest
[0] = rotr32 (digest
[0], 29);
11414 digest
[1] = rotr32 (digest
[1], 29);
11415 digest
[2] = rotr32 (digest
[2], 29);
11416 digest
[3] = rotr32 (digest
[3], 29);
11418 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11420 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11421 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11423 return (PARSER_OK
);
11426 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11428 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11430 u32
*digest
= (u32
*) hash_buf
->digest
;
11432 salt_t
*salt
= hash_buf
->salt
;
11434 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11440 char *user_pos
= input_buf
;
11442 char *unused_pos
= strchr (user_pos
, ':');
11444 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11446 uint user_len
= unused_pos
- user_pos
;
11448 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11452 char *domain_pos
= strchr (unused_pos
, ':');
11454 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11456 uint unused_len
= domain_pos
- unused_pos
;
11458 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11462 char *srvchall_pos
= strchr (domain_pos
, ':');
11464 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11466 uint domain_len
= srvchall_pos
- domain_pos
;
11468 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11472 char *hash_pos
= strchr (srvchall_pos
, ':');
11474 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11476 uint srvchall_len
= hash_pos
- srvchall_pos
;
11478 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11482 char *clichall_pos
= strchr (hash_pos
, ':');
11484 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11486 uint hash_len
= clichall_pos
- hash_pos
;
11488 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11492 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11494 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11496 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11499 * store some data for later use
11502 netntlm
->user_len
= user_len
* 2;
11503 netntlm
->domain_len
= domain_len
* 2;
11504 netntlm
->srvchall_len
= srvchall_len
/ 2;
11505 netntlm
->clichall_len
= clichall_len
/ 2;
11507 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11508 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11511 * handle username and domainname
11514 for (uint i
= 0; i
< user_len
; i
++)
11516 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11517 *userdomain_ptr
++ = 0;
11520 for (uint i
= 0; i
< domain_len
; i
++)
11522 *userdomain_ptr
++ = domain_pos
[i
];
11523 *userdomain_ptr
++ = 0;
11526 *userdomain_ptr
++ = 0x80;
11529 * handle server challenge encoding
11532 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11534 const char p0
= srvchall_pos
[i
+ 0];
11535 const char p1
= srvchall_pos
[i
+ 1];
11537 *chall_ptr
++ = hex_convert (p1
) << 0
11538 | hex_convert (p0
) << 4;
11542 * handle client challenge encoding
11545 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11547 const char p0
= clichall_pos
[i
+ 0];
11548 const char p1
= clichall_pos
[i
+ 1];
11550 *chall_ptr
++ = hex_convert (p1
) << 0
11551 | hex_convert (p0
) << 4;
11554 *chall_ptr
++ = 0x80;
11557 * handle hash itself
11560 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11561 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11562 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11563 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11565 digest
[0] = byte_swap_32 (digest
[0]);
11566 digest
[1] = byte_swap_32 (digest
[1]);
11567 digest
[2] = byte_swap_32 (digest
[2]);
11568 digest
[3] = byte_swap_32 (digest
[3]);
11571 * reuse challange data as salt_buf, its the buffer that is most likely unique
11574 salt
->salt_buf
[0] = 0;
11575 salt
->salt_buf
[1] = 0;
11576 salt
->salt_buf
[2] = 0;
11577 salt
->salt_buf
[3] = 0;
11578 salt
->salt_buf
[4] = 0;
11579 salt
->salt_buf
[5] = 0;
11580 salt
->salt_buf
[6] = 0;
11581 salt
->salt_buf
[7] = 0;
11585 uptr
= (uint
*) netntlm
->userdomain_buf
;
11587 for (uint i
= 0; i
< 16; i
+= 16)
11589 md5_64 (uptr
, salt
->salt_buf
);
11592 uptr
= (uint
*) netntlm
->chall_buf
;
11594 for (uint i
= 0; i
< 256; i
+= 16)
11596 md5_64 (uptr
, salt
->salt_buf
);
11599 salt
->salt_len
= 16;
11601 return (PARSER_OK
);
11604 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11606 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11608 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11612 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11615 u32
*digest
= (u32
*) hash_buf
->digest
;
11617 salt_t
*salt
= hash_buf
->salt
;
11619 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11620 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11621 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11622 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11624 digest
[0] = byte_swap_32 (digest
[0]);
11625 digest
[1] = byte_swap_32 (digest
[1]);
11626 digest
[2] = byte_swap_32 (digest
[2]);
11627 digest
[3] = byte_swap_32 (digest
[3]);
11629 digest
[0] -= MD5M_A
;
11630 digest
[1] -= MD5M_B
;
11631 digest
[2] -= MD5M_C
;
11632 digest
[3] -= MD5M_D
;
11634 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11636 uint salt_len
= input_len
- 32 - 1;
11638 char *salt_buf
= input_buf
+ 32 + 1;
11640 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11642 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11644 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11646 salt
->salt_len
= salt_len
;
11648 return (PARSER_OK
);
11651 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11653 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11655 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11659 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11662 u32
*digest
= (u32
*) hash_buf
->digest
;
11664 salt_t
*salt
= hash_buf
->salt
;
11666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11671 digest
[0] = byte_swap_32 (digest
[0]);
11672 digest
[1] = byte_swap_32 (digest
[1]);
11673 digest
[2] = byte_swap_32 (digest
[2]);
11674 digest
[3] = byte_swap_32 (digest
[3]);
11676 digest
[0] -= MD5M_A
;
11677 digest
[1] -= MD5M_B
;
11678 digest
[2] -= MD5M_C
;
11679 digest
[3] -= MD5M_D
;
11681 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11683 uint salt_len
= input_len
- 32 - 1;
11685 char *salt_buf
= input_buf
+ 32 + 1;
11687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11693 salt
->salt_len
= salt_len
;
11695 return (PARSER_OK
);
11698 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11700 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11702 u32
*digest
= (u32
*) hash_buf
->digest
;
11704 salt_t
*salt
= hash_buf
->salt
;
11706 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11707 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11708 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11709 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11711 digest
[0] = byte_swap_32 (digest
[0]);
11712 digest
[1] = byte_swap_32 (digest
[1]);
11713 digest
[2] = byte_swap_32 (digest
[2]);
11714 digest
[3] = byte_swap_32 (digest
[3]);
11716 digest
[0] -= MD5M_A
;
11717 digest
[1] -= MD5M_B
;
11718 digest
[2] -= MD5M_C
;
11719 digest
[3] -= MD5M_D
;
11722 * This is a virtual salt. While the algorithm is basically not salted
11723 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11724 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11729 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11733 salt
->salt_len
= salt_len
;
11735 return (PARSER_OK
);
11738 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11740 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11742 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11746 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11749 u32
*digest
= (u32
*) hash_buf
->digest
;
11751 salt_t
*salt
= hash_buf
->salt
;
11753 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11754 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11755 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11756 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11758 digest
[0] = byte_swap_32 (digest
[0]);
11759 digest
[1] = byte_swap_32 (digest
[1]);
11760 digest
[2] = byte_swap_32 (digest
[2]);
11761 digest
[3] = byte_swap_32 (digest
[3]);
11763 digest
[0] -= MD5M_A
;
11764 digest
[1] -= MD5M_B
;
11765 digest
[2] -= MD5M_C
;
11766 digest
[3] -= MD5M_D
;
11768 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11770 uint salt_len
= input_len
- 32 - 1;
11772 char *salt_buf
= input_buf
+ 32 + 1;
11774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11776 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11780 salt
->salt_len
= salt_len
;
11782 return (PARSER_OK
);
11785 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11787 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11789 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11793 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11796 u32
*digest
= (u32
*) hash_buf
->digest
;
11798 salt_t
*salt
= hash_buf
->salt
;
11800 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11801 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11802 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11803 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11805 digest
[0] = byte_swap_32 (digest
[0]);
11806 digest
[1] = byte_swap_32 (digest
[1]);
11807 digest
[2] = byte_swap_32 (digest
[2]);
11808 digest
[3] = byte_swap_32 (digest
[3]);
11810 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11812 uint salt_len
= input_len
- 32 - 1;
11814 char *salt_buf
= input_buf
+ 32 + 1;
11816 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11818 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11820 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11822 salt
->salt_len
= salt_len
;
11824 return (PARSER_OK
);
11827 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11829 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11831 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11835 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11838 u32
*digest
= (u32
*) hash_buf
->digest
;
11840 salt_t
*salt
= hash_buf
->salt
;
11842 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11843 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11844 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11845 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11847 digest
[0] = byte_swap_32 (digest
[0]);
11848 digest
[1] = byte_swap_32 (digest
[1]);
11849 digest
[2] = byte_swap_32 (digest
[2]);
11850 digest
[3] = byte_swap_32 (digest
[3]);
11852 digest
[0] -= MD4M_A
;
11853 digest
[1] -= MD4M_B
;
11854 digest
[2] -= MD4M_C
;
11855 digest
[3] -= MD4M_D
;
11857 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11859 uint salt_len
= input_len
- 32 - 1;
11861 char *salt_buf
= input_buf
+ 32 + 1;
11863 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11865 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11867 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11869 salt
->salt_len
= salt_len
;
11871 return (PARSER_OK
);
11874 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11876 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11878 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11882 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11885 u32
*digest
= (u32
*) hash_buf
->digest
;
11887 salt_t
*salt
= hash_buf
->salt
;
11889 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11890 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11891 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11892 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11894 digest
[0] = byte_swap_32 (digest
[0]);
11895 digest
[1] = byte_swap_32 (digest
[1]);
11896 digest
[2] = byte_swap_32 (digest
[2]);
11897 digest
[3] = byte_swap_32 (digest
[3]);
11899 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11901 uint salt_len
= input_len
- 32 - 1;
11903 char *salt_buf
= input_buf
+ 32 + 1;
11905 uint salt_pc_block
[16] = { 0 };
11907 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11909 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11911 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11913 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11915 salt_pc_block
[14] = salt_len
* 8;
11917 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11919 md5_64 (salt_pc_block
, salt_pc_digest
);
11921 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11922 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11923 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11924 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11926 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11928 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11930 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11932 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11933 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11934 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11935 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11937 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11939 return (PARSER_OK
);
11942 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11944 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11946 u32
*digest
= (u32
*) hash_buf
->digest
;
11948 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11949 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11950 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11951 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11952 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11954 digest
[0] -= SHA1M_A
;
11955 digest
[1] -= SHA1M_B
;
11956 digest
[2] -= SHA1M_C
;
11957 digest
[3] -= SHA1M_D
;
11958 digest
[4] -= SHA1M_E
;
11960 return (PARSER_OK
);
11963 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11965 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11967 u32
*digest
= (u32
*) hash_buf
->digest
;
11969 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11970 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11971 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11972 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11973 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11975 return (PARSER_OK
);
11978 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11980 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11982 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11984 u32
*digest
= (u32
*) hash_buf
->digest
;
11988 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11989 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11990 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11991 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11994 return (PARSER_OK
);
11997 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11999 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12001 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12005 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12008 u32
*digest
= (u32
*) hash_buf
->digest
;
12010 salt_t
*salt
= hash_buf
->salt
;
12012 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12013 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12014 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12015 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12016 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12018 digest
[0] -= SHA1M_A
;
12019 digest
[1] -= SHA1M_B
;
12020 digest
[2] -= SHA1M_C
;
12021 digest
[3] -= SHA1M_D
;
12022 digest
[4] -= SHA1M_E
;
12024 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12026 uint salt_len
= input_len
- 40 - 1;
12028 char *salt_buf
= input_buf
+ 40 + 1;
12030 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12032 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12036 salt
->salt_len
= salt_len
;
12038 return (PARSER_OK
);
12041 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12043 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12045 u32
*digest
= (u32
*) hash_buf
->digest
;
12047 salt_t
*salt
= hash_buf
->salt
;
12049 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12055 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12057 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12059 uint salt_len
= input_len
- 40 - 1;
12061 char *salt_buf
= input_buf
+ 40 + 1;
12063 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12065 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12067 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12069 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12072 pstoken
->salt_len
= salt_len
/ 2;
12074 /* some fake salt for the sorting mechanisms */
12076 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12077 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12078 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12079 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12080 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12081 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12082 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12083 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12085 salt
->salt_len
= 32;
12087 /* we need to check if we can precompute some of the data --
12088 this is possible since the scheme is badly designed */
12090 pstoken
->pc_digest
[0] = SHA1M_A
;
12091 pstoken
->pc_digest
[1] = SHA1M_B
;
12092 pstoken
->pc_digest
[2] = SHA1M_C
;
12093 pstoken
->pc_digest
[3] = SHA1M_D
;
12094 pstoken
->pc_digest
[4] = SHA1M_E
;
12096 pstoken
->pc_offset
= 0;
12098 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12102 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12103 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12104 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12105 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12106 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12107 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12108 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12109 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12110 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12111 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12112 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12113 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12114 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12115 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12116 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12117 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12119 sha1_64 (w
, pstoken
->pc_digest
);
12121 pstoken
->pc_offset
+= 16;
12124 return (PARSER_OK
);
12127 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12129 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12131 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12133 u32
*digest
= (u32
*) hash_buf
->digest
;
12135 u8 tmp_buf
[100] = { 0 };
12137 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12139 memcpy (digest
, tmp_buf
, 20);
12141 digest
[0] = byte_swap_32 (digest
[0]);
12142 digest
[1] = byte_swap_32 (digest
[1]);
12143 digest
[2] = byte_swap_32 (digest
[2]);
12144 digest
[3] = byte_swap_32 (digest
[3]);
12145 digest
[4] = byte_swap_32 (digest
[4]);
12147 digest
[0] -= SHA1M_A
;
12148 digest
[1] -= SHA1M_B
;
12149 digest
[2] -= SHA1M_C
;
12150 digest
[3] -= SHA1M_D
;
12151 digest
[4] -= SHA1M_E
;
12153 return (PARSER_OK
);
12156 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12158 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12160 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12162 u32
*digest
= (u32
*) hash_buf
->digest
;
12164 salt_t
*salt
= hash_buf
->salt
;
12166 u8 tmp_buf
[100] = { 0 };
12168 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12170 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12172 memcpy (digest
, tmp_buf
, 20);
12174 int salt_len
= tmp_len
- 20;
12176 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12178 salt
->salt_len
= salt_len
;
12180 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12182 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12184 char *ptr
= (char *) salt
->salt_buf
;
12186 ptr
[salt
->salt_len
] = 0x80;
12189 digest
[0] = byte_swap_32 (digest
[0]);
12190 digest
[1] = byte_swap_32 (digest
[1]);
12191 digest
[2] = byte_swap_32 (digest
[2]);
12192 digest
[3] = byte_swap_32 (digest
[3]);
12193 digest
[4] = byte_swap_32 (digest
[4]);
12195 digest
[0] -= SHA1M_A
;
12196 digest
[1] -= SHA1M_B
;
12197 digest
[2] -= SHA1M_C
;
12198 digest
[3] -= SHA1M_D
;
12199 digest
[4] -= SHA1M_E
;
12201 return (PARSER_OK
);
12204 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12206 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12208 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12210 u32
*digest
= (u32
*) hash_buf
->digest
;
12212 salt_t
*salt
= hash_buf
->salt
;
12214 char *salt_buf
= input_buf
+ 6;
12218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12220 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12222 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12224 salt
->salt_len
= salt_len
;
12226 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12228 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12229 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12230 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12231 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12232 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12234 digest
[0] -= SHA1M_A
;
12235 digest
[1] -= SHA1M_B
;
12236 digest
[2] -= SHA1M_C
;
12237 digest
[3] -= SHA1M_D
;
12238 digest
[4] -= SHA1M_E
;
12240 return (PARSER_OK
);
12243 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12245 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12247 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12249 u32
*digest
= (u32
*) hash_buf
->digest
;
12251 salt_t
*salt
= hash_buf
->salt
;
12253 char *salt_buf
= input_buf
+ 6;
12257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12259 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12261 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12263 salt
->salt_len
= salt_len
;
12265 char *hash_pos
= input_buf
+ 6 + 8;
12267 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12268 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12269 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12270 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12271 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12273 digest
[0] -= SHA1M_A
;
12274 digest
[1] -= SHA1M_B
;
12275 digest
[2] -= SHA1M_C
;
12276 digest
[3] -= SHA1M_D
;
12277 digest
[4] -= SHA1M_E
;
12279 return (PARSER_OK
);
12282 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12284 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12286 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12288 u64
*digest
= (u64
*) hash_buf
->digest
;
12290 salt_t
*salt
= hash_buf
->salt
;
12292 char *salt_buf
= input_buf
+ 6;
12296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12298 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12302 salt
->salt_len
= salt_len
;
12304 char *hash_pos
= input_buf
+ 6 + 8;
12306 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12307 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12308 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12309 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12310 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12311 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12312 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12313 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12315 digest
[0] -= SHA512M_A
;
12316 digest
[1] -= SHA512M_B
;
12317 digest
[2] -= SHA512M_C
;
12318 digest
[3] -= SHA512M_D
;
12319 digest
[4] -= SHA512M_E
;
12320 digest
[5] -= SHA512M_F
;
12321 digest
[6] -= SHA512M_G
;
12322 digest
[7] -= SHA512M_H
;
12324 return (PARSER_OK
);
12327 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12329 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12331 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12335 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12338 u32
*digest
= (u32
*) hash_buf
->digest
;
12340 salt_t
*salt
= hash_buf
->salt
;
12342 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12343 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12347 digest
[0] = byte_swap_32 (digest
[0]);
12348 digest
[1] = byte_swap_32 (digest
[1]);
12350 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12352 uint salt_len
= input_len
- 16 - 1;
12354 char *salt_buf
= input_buf
+ 16 + 1;
12356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12360 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12362 salt
->salt_len
= salt_len
;
12364 return (PARSER_OK
);
12367 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12369 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12371 u32
*digest
= (u32
*) hash_buf
->digest
;
12373 salt_t
*salt
= hash_buf
->salt
;
12375 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12376 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12377 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12378 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12379 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12381 digest
[0] -= SHA1M_A
;
12382 digest
[1] -= SHA1M_B
;
12383 digest
[2] -= SHA1M_C
;
12384 digest
[3] -= SHA1M_D
;
12385 digest
[4] -= SHA1M_E
;
12387 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12389 uint salt_len
= input_len
- 40 - 1;
12391 char *salt_buf
= input_buf
+ 40 + 1;
12393 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12395 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12397 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12399 salt
->salt_len
= salt_len
;
12401 return (PARSER_OK
);
12404 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12408 u32
*digest
= (u32
*) hash_buf
->digest
;
12410 salt_t
*salt
= hash_buf
->salt
;
12412 char *hash_pos
= input_buf
;
12414 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12415 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12416 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12417 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12418 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12419 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12420 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12421 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12422 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12423 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12424 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12425 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12426 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12427 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12428 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12429 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12431 char *salt_pos
= input_buf
+ 128;
12433 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12434 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12435 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12436 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12438 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12439 salt
->salt_len
= 16;
12441 return (PARSER_OK
);
12444 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12446 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12448 u32
*digest
= (u32
*) hash_buf
->digest
;
12450 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12451 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12452 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12453 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12454 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12455 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12456 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12457 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12459 digest
[0] -= SHA256M_A
;
12460 digest
[1] -= SHA256M_B
;
12461 digest
[2] -= SHA256M_C
;
12462 digest
[3] -= SHA256M_D
;
12463 digest
[4] -= SHA256M_E
;
12464 digest
[5] -= SHA256M_F
;
12465 digest
[6] -= SHA256M_G
;
12466 digest
[7] -= SHA256M_H
;
12468 return (PARSER_OK
);
12471 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12473 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12475 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12479 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12482 u32
*digest
= (u32
*) hash_buf
->digest
;
12484 salt_t
*salt
= hash_buf
->salt
;
12486 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12487 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12488 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12489 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12490 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12491 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12492 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12493 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12495 digest
[0] -= SHA256M_A
;
12496 digest
[1] -= SHA256M_B
;
12497 digest
[2] -= SHA256M_C
;
12498 digest
[3] -= SHA256M_D
;
12499 digest
[4] -= SHA256M_E
;
12500 digest
[5] -= SHA256M_F
;
12501 digest
[6] -= SHA256M_G
;
12502 digest
[7] -= SHA256M_H
;
12504 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12506 uint salt_len
= input_len
- 64 - 1;
12508 char *salt_buf
= input_buf
+ 64 + 1;
12510 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12512 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12514 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12516 salt
->salt_len
= salt_len
;
12518 return (PARSER_OK
);
12521 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12523 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12525 u64
*digest
= (u64
*) hash_buf
->digest
;
12527 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12528 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12529 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12530 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12531 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12532 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12536 digest
[0] -= SHA384M_A
;
12537 digest
[1] -= SHA384M_B
;
12538 digest
[2] -= SHA384M_C
;
12539 digest
[3] -= SHA384M_D
;
12540 digest
[4] -= SHA384M_E
;
12541 digest
[5] -= SHA384M_F
;
12545 return (PARSER_OK
);
12548 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12550 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12552 u64
*digest
= (u64
*) hash_buf
->digest
;
12554 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12555 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12556 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12557 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12558 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12559 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12560 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12561 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12563 digest
[0] -= SHA512M_A
;
12564 digest
[1] -= SHA512M_B
;
12565 digest
[2] -= SHA512M_C
;
12566 digest
[3] -= SHA512M_D
;
12567 digest
[4] -= SHA512M_E
;
12568 digest
[5] -= SHA512M_F
;
12569 digest
[6] -= SHA512M_G
;
12570 digest
[7] -= SHA512M_H
;
12572 return (PARSER_OK
);
12575 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12577 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12579 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12583 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12586 u64
*digest
= (u64
*) hash_buf
->digest
;
12588 salt_t
*salt
= hash_buf
->salt
;
12590 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12591 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12592 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12593 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12594 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12595 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12596 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12597 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12599 digest
[0] -= SHA512M_A
;
12600 digest
[1] -= SHA512M_B
;
12601 digest
[2] -= SHA512M_C
;
12602 digest
[3] -= SHA512M_D
;
12603 digest
[4] -= SHA512M_E
;
12604 digest
[5] -= SHA512M_F
;
12605 digest
[6] -= SHA512M_G
;
12606 digest
[7] -= SHA512M_H
;
12608 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12610 uint salt_len
= input_len
- 128 - 1;
12612 char *salt_buf
= input_buf
+ 128 + 1;
12614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12616 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12620 salt
->salt_len
= salt_len
;
12622 return (PARSER_OK
);
12625 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12627 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12629 u64
*digest
= (u64
*) hash_buf
->digest
;
12631 salt_t
*salt
= hash_buf
->salt
;
12633 char *salt_pos
= input_buf
+ 3;
12635 uint iterations_len
= 0;
12637 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12641 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12643 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12644 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12648 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12652 iterations_len
+= 8;
12656 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12659 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12661 char *hash_pos
= strchr (salt_pos
, '$');
12663 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12665 uint salt_len
= hash_pos
- salt_pos
;
12667 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12669 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12671 salt
->salt_len
= salt_len
;
12675 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12677 return (PARSER_OK
);
12680 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12682 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12684 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12686 u64
*digest
= (u64
*) hash_buf
->digest
;
12688 salt_t
*salt
= hash_buf
->salt
;
12690 uint keccak_mdlen
= input_len
/ 2;
12692 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12694 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12696 digest
[i
] = byte_swap_64 (digest
[i
]);
12699 salt
->keccak_mdlen
= keccak_mdlen
;
12701 return (PARSER_OK
);
12704 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12706 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12708 u32
*digest
= (u32
*) hash_buf
->digest
;
12710 salt_t
*salt
= hash_buf
->salt
;
12712 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12715 * Parse that strange long line
12720 size_t in_len
[9] = { 0 };
12722 in_off
[0] = strtok (input_buf
, ":");
12724 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12726 in_len
[0] = strlen (in_off
[0]);
12730 for (i
= 1; i
< 9; i
++)
12732 in_off
[i
] = strtok (NULL
, ":");
12734 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12736 in_len
[i
] = strlen (in_off
[i
]);
12739 char *ptr
= (char *) ikepsk
->msg_buf
;
12741 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12742 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12743 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12744 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12745 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12746 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12750 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12752 ptr
= (char *) ikepsk
->nr_buf
;
12754 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12755 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12759 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12762 * Store to database
12767 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12768 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12769 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12770 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12772 digest
[0] = byte_swap_32 (digest
[0]);
12773 digest
[1] = byte_swap_32 (digest
[1]);
12774 digest
[2] = byte_swap_32 (digest
[2]);
12775 digest
[3] = byte_swap_32 (digest
[3]);
12777 salt
->salt_len
= 32;
12779 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12780 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12781 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12782 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12783 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12784 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12785 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12786 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12788 return (PARSER_OK
);
12791 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12793 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12795 u32
*digest
= (u32
*) hash_buf
->digest
;
12797 salt_t
*salt
= hash_buf
->salt
;
12799 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12802 * Parse that strange long line
12807 size_t in_len
[9] = { 0 };
12809 in_off
[0] = strtok (input_buf
, ":");
12811 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12813 in_len
[0] = strlen (in_off
[0]);
12817 for (i
= 1; i
< 9; i
++)
12819 in_off
[i
] = strtok (NULL
, ":");
12821 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12823 in_len
[i
] = strlen (in_off
[i
]);
12826 char *ptr
= (char *) ikepsk
->msg_buf
;
12828 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12829 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12830 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12831 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12832 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12833 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12837 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12839 ptr
= (char *) ikepsk
->nr_buf
;
12841 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12842 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12846 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12849 * Store to database
12854 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12855 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12856 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12857 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12858 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12860 salt
->salt_len
= 32;
12862 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12863 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12864 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12865 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12866 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12867 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12868 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12869 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12871 return (PARSER_OK
);
12874 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12876 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12878 u32
*digest
= (u32
*) hash_buf
->digest
;
12880 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12881 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12882 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12883 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12884 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12886 digest
[0] = byte_swap_32 (digest
[0]);
12887 digest
[1] = byte_swap_32 (digest
[1]);
12888 digest
[2] = byte_swap_32 (digest
[2]);
12889 digest
[3] = byte_swap_32 (digest
[3]);
12890 digest
[4] = byte_swap_32 (digest
[4]);
12892 return (PARSER_OK
);
12895 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12897 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12899 u32
*digest
= (u32
*) hash_buf
->digest
;
12901 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12902 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12903 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12904 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12905 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12906 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12907 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12908 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12909 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12910 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12911 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12912 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12913 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12914 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12915 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12916 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12918 return (PARSER_OK
);
12921 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12923 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12925 u32
*digest
= (u32
*) hash_buf
->digest
;
12927 salt_t
*salt
= hash_buf
->salt
;
12929 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12930 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12931 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12932 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12933 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12935 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12937 uint salt_len
= input_len
- 40 - 1;
12939 char *salt_buf
= input_buf
+ 40 + 1;
12941 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12943 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12945 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12947 salt
->salt_len
= salt_len
;
12949 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12951 return (PARSER_OK
);
12954 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12956 u32
*digest
= (u32
*) hash_buf
->digest
;
12958 salt_t
*salt
= hash_buf
->salt
;
12960 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12962 if (input_len
== 0)
12964 log_error ("TrueCrypt container not specified");
12969 FILE *fp
= fopen (input_buf
, "rb");
12973 log_error ("%s: %s", input_buf
, strerror (errno
));
12978 char buf
[512] = { 0 };
12980 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12984 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12986 memcpy (tc
->salt_buf
, buf
, 64);
12988 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12990 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12992 salt
->salt_len
= 4;
12994 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12996 tc
->signature
= 0x45555254; // "TRUE"
12998 digest
[0] = tc
->data_buf
[0];
13000 return (PARSER_OK
);
13003 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13005 u32
*digest
= (u32
*) hash_buf
->digest
;
13007 salt_t
*salt
= hash_buf
->salt
;
13009 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13011 if (input_len
== 0)
13013 log_error ("TrueCrypt container not specified");
13018 FILE *fp
= fopen (input_buf
, "rb");
13022 log_error ("%s: %s", input_buf
, strerror (errno
));
13027 char buf
[512] = { 0 };
13029 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13033 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13035 memcpy (tc
->salt_buf
, buf
, 64);
13037 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13039 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13041 salt
->salt_len
= 4;
13043 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13045 tc
->signature
= 0x45555254; // "TRUE"
13047 digest
[0] = tc
->data_buf
[0];
13049 return (PARSER_OK
);
13052 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13054 u32
*digest
= (u32
*) hash_buf
->digest
;
13056 salt_t
*salt
= hash_buf
->salt
;
13058 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13060 if (input_len
== 0)
13062 log_error ("VeraCrypt container not specified");
13067 FILE *fp
= fopen (input_buf
, "rb");
13071 log_error ("%s: %s", input_buf
, strerror (errno
));
13076 char buf
[512] = { 0 };
13078 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13082 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13084 memcpy (tc
->salt_buf
, buf
, 64);
13086 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13088 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13090 salt
->salt_len
= 4;
13092 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13094 tc
->signature
= 0x41524556; // "VERA"
13096 digest
[0] = tc
->data_buf
[0];
13098 return (PARSER_OK
);
13101 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13103 u32
*digest
= (u32
*) hash_buf
->digest
;
13105 salt_t
*salt
= hash_buf
->salt
;
13107 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13109 if (input_len
== 0)
13111 log_error ("VeraCrypt container not specified");
13116 FILE *fp
= fopen (input_buf
, "rb");
13120 log_error ("%s: %s", input_buf
, strerror (errno
));
13125 char buf
[512] = { 0 };
13127 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13131 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13133 memcpy (tc
->salt_buf
, buf
, 64);
13135 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13137 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13139 salt
->salt_len
= 4;
13141 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13143 tc
->signature
= 0x41524556; // "VERA"
13145 digest
[0] = tc
->data_buf
[0];
13147 return (PARSER_OK
);
13150 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13152 u32
*digest
= (u32
*) hash_buf
->digest
;
13154 salt_t
*salt
= hash_buf
->salt
;
13156 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13158 if (input_len
== 0)
13160 log_error ("VeraCrypt container not specified");
13165 FILE *fp
= fopen (input_buf
, "rb");
13169 log_error ("%s: %s", input_buf
, strerror (errno
));
13174 char buf
[512] = { 0 };
13176 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13180 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13182 memcpy (tc
->salt_buf
, buf
, 64);
13184 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13186 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13188 salt
->salt_len
= 4;
13190 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13192 tc
->signature
= 0x41524556; // "VERA"
13194 digest
[0] = tc
->data_buf
[0];
13196 return (PARSER_OK
);
13199 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13201 u32
*digest
= (u32
*) hash_buf
->digest
;
13203 salt_t
*salt
= hash_buf
->salt
;
13205 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13207 if (input_len
== 0)
13209 log_error ("VeraCrypt container not specified");
13214 FILE *fp
= fopen (input_buf
, "rb");
13218 log_error ("%s: %s", input_buf
, strerror (errno
));
13223 char buf
[512] = { 0 };
13225 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13229 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13231 memcpy (tc
->salt_buf
, buf
, 64);
13233 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13235 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13237 salt
->salt_len
= 4;
13239 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13241 tc
->signature
= 0x41524556; // "VERA"
13243 digest
[0] = tc
->data_buf
[0];
13245 return (PARSER_OK
);
13248 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13250 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13252 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13254 u32
*digest
= (u32
*) hash_buf
->digest
;
13256 salt_t
*salt
= hash_buf
->salt
;
13258 char *salt_pos
= input_buf
+ 6;
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
< 8) return (PARSER_SALT_LENGTH
);
13268 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13270 salt
->salt_len
= salt_len
;
13272 salt
->salt_iter
= 1000;
13276 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13278 return (PARSER_OK
);
13281 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13283 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13285 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13287 u32
*digest
= (u32
*) hash_buf
->digest
;
13289 salt_t
*salt
= hash_buf
->salt
;
13291 char *iter_pos
= input_buf
+ 7;
13293 char *salt_pos
= strchr (iter_pos
, '$');
13295 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13299 char *hash_pos
= strchr (salt_pos
, '$');
13301 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13303 uint salt_len
= hash_pos
- salt_pos
;
13305 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13307 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13309 salt
->salt_len
= salt_len
;
13311 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13313 salt
->salt_sign
[0] = atoi (salt_iter
);
13315 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13319 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13321 digest
[0] = byte_swap_32 (digest
[0]);
13322 digest
[1] = byte_swap_32 (digest
[1]);
13323 digest
[2] = byte_swap_32 (digest
[2]);
13324 digest
[3] = byte_swap_32 (digest
[3]);
13325 digest
[4] = byte_swap_32 (digest
[4]);
13327 return (PARSER_OK
);
13330 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13332 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13334 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13336 u32
*digest
= (u32
*) hash_buf
->digest
;
13338 salt_t
*salt
= hash_buf
->salt
;
13340 char *iter_pos
= input_buf
+ 9;
13342 char *salt_pos
= strchr (iter_pos
, '$');
13344 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13348 char *hash_pos
= strchr (salt_pos
, '$');
13350 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13352 uint salt_len
= hash_pos
- salt_pos
;
13354 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13356 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13358 salt
->salt_len
= salt_len
;
13360 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13362 salt
->salt_sign
[0] = atoi (salt_iter
);
13364 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13368 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13370 digest
[0] = byte_swap_32 (digest
[0]);
13371 digest
[1] = byte_swap_32 (digest
[1]);
13372 digest
[2] = byte_swap_32 (digest
[2]);
13373 digest
[3] = byte_swap_32 (digest
[3]);
13374 digest
[4] = byte_swap_32 (digest
[4]);
13375 digest
[5] = byte_swap_32 (digest
[5]);
13376 digest
[6] = byte_swap_32 (digest
[6]);
13377 digest
[7] = byte_swap_32 (digest
[7]);
13379 return (PARSER_OK
);
13382 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13384 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13386 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13388 u64
*digest
= (u64
*) hash_buf
->digest
;
13390 salt_t
*salt
= hash_buf
->salt
;
13392 char *iter_pos
= input_buf
+ 9;
13394 char *salt_pos
= strchr (iter_pos
, '$');
13396 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13400 char *hash_pos
= strchr (salt_pos
, '$');
13402 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13404 uint salt_len
= hash_pos
- salt_pos
;
13406 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13408 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13410 salt
->salt_len
= salt_len
;
13412 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13414 salt
->salt_sign
[0] = atoi (salt_iter
);
13416 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13420 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13422 digest
[0] = byte_swap_64 (digest
[0]);
13423 digest
[1] = byte_swap_64 (digest
[1]);
13424 digest
[2] = byte_swap_64 (digest
[2]);
13425 digest
[3] = byte_swap_64 (digest
[3]);
13426 digest
[4] = byte_swap_64 (digest
[4]);
13427 digest
[5] = byte_swap_64 (digest
[5]);
13428 digest
[6] = byte_swap_64 (digest
[6]);
13429 digest
[7] = byte_swap_64 (digest
[7]);
13431 return (PARSER_OK
);
13434 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13436 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13438 u32
*digest
= (u32
*) hash_buf
->digest
;
13440 salt_t
*salt
= hash_buf
->salt
;
13442 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13448 char *iterations_pos
= input_buf
;
13450 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13452 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13454 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13456 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13460 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13462 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13464 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13466 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13468 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13470 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13475 * pbkdf2 iterations
13478 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13481 * handle salt encoding
13484 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13486 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13488 const char p0
= saltbuf_pos
[i
+ 0];
13489 const char p1
= saltbuf_pos
[i
+ 1];
13491 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13492 | hex_convert (p0
) << 4;
13495 salt
->salt_len
= saltbuf_len
/ 2;
13498 * handle cipher encoding
13501 uint
*tmp
= (uint
*) mymalloc (32);
13503 char *cipherbuf_ptr
= (char *) tmp
;
13505 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13507 const char p0
= cipherbuf_pos
[i
+ 0];
13508 const char p1
= cipherbuf_pos
[i
+ 1];
13510 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13511 | hex_convert (p0
) << 4;
13514 // iv is stored at salt_buf 4 (length 16)
13515 // data is stored at salt_buf 8 (length 16)
13517 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13518 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13519 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13520 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13522 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13523 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13524 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13525 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13529 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13531 const char p0
= cipherbuf_pos
[j
+ 0];
13532 const char p1
= cipherbuf_pos
[j
+ 1];
13534 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13535 | hex_convert (p0
) << 4;
13542 digest
[0] = 0x10101010;
13543 digest
[1] = 0x10101010;
13544 digest
[2] = 0x10101010;
13545 digest
[3] = 0x10101010;
13547 return (PARSER_OK
);
13550 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13552 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13554 u32
*digest
= (u32
*) hash_buf
->digest
;
13556 salt_t
*salt
= hash_buf
->salt
;
13558 char *hashbuf_pos
= input_buf
;
13560 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13562 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13564 uint hash_len
= iterations_pos
- hashbuf_pos
;
13566 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13570 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13572 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13574 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13578 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13580 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13584 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13586 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13588 salt
->salt_len
= salt_len
;
13590 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13592 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13593 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13594 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13595 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13597 return (PARSER_OK
);
13600 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13602 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13604 u32
*digest
= (u32
*) hash_buf
->digest
;
13606 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13607 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13608 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13609 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13610 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13611 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13612 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13613 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13615 digest
[0] = byte_swap_32 (digest
[0]);
13616 digest
[1] = byte_swap_32 (digest
[1]);
13617 digest
[2] = byte_swap_32 (digest
[2]);
13618 digest
[3] = byte_swap_32 (digest
[3]);
13619 digest
[4] = byte_swap_32 (digest
[4]);
13620 digest
[5] = byte_swap_32 (digest
[5]);
13621 digest
[6] = byte_swap_32 (digest
[6]);
13622 digest
[7] = byte_swap_32 (digest
[7]);
13624 return (PARSER_OK
);
13627 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13629 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13631 u32
*digest
= (u32
*) hash_buf
->digest
;
13633 salt_t
*salt
= hash_buf
->salt
;
13635 char *salt_pos
= input_buf
+ 3;
13637 uint iterations_len
= 0;
13639 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13643 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13645 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13646 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13650 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13654 iterations_len
+= 8;
13658 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13661 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13663 char *hash_pos
= strchr (salt_pos
, '$');
13665 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13667 uint salt_len
= hash_pos
- salt_pos
;
13669 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13671 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13673 salt
->salt_len
= salt_len
;
13677 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13679 return (PARSER_OK
);
13682 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13684 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13686 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13688 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13690 u64
*digest
= (u64
*) hash_buf
->digest
;
13692 salt_t
*salt
= hash_buf
->salt
;
13694 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13696 char *iter_pos
= input_buf
+ 4;
13698 char *salt_pos
= strchr (iter_pos
, '$');
13700 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13704 char *hash_pos
= strchr (salt_pos
, '$');
13706 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13708 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13712 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13713 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13714 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13715 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13716 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13717 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13718 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13719 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13721 uint salt_len
= hash_pos
- salt_pos
- 1;
13723 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13725 salt
->salt_len
= salt_len
/ 2;
13727 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13728 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13729 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13730 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13731 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13732 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13733 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13734 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13736 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13737 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13738 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13739 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13740 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13741 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13742 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13743 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13744 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13745 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13747 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13749 salt
->salt_iter
= atoi (iter_pos
) - 1;
13751 return (PARSER_OK
);
13754 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13756 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13758 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13760 u32
*digest
= (u32
*) hash_buf
->digest
;
13762 salt_t
*salt
= hash_buf
->salt
;
13764 char *salt_pos
= input_buf
+ 14;
13766 char *hash_pos
= strchr (salt_pos
, '*');
13768 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13772 uint salt_len
= hash_pos
- salt_pos
- 1;
13774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13776 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13780 salt
->salt_len
= salt_len
;
13782 u8 tmp_buf
[100] = { 0 };
13784 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13786 memcpy (digest
, tmp_buf
, 32);
13788 digest
[0] = byte_swap_32 (digest
[0]);
13789 digest
[1] = byte_swap_32 (digest
[1]);
13790 digest
[2] = byte_swap_32 (digest
[2]);
13791 digest
[3] = byte_swap_32 (digest
[3]);
13792 digest
[4] = byte_swap_32 (digest
[4]);
13793 digest
[5] = byte_swap_32 (digest
[5]);
13794 digest
[6] = byte_swap_32 (digest
[6]);
13795 digest
[7] = byte_swap_32 (digest
[7]);
13797 digest
[0] -= SHA256M_A
;
13798 digest
[1] -= SHA256M_B
;
13799 digest
[2] -= SHA256M_C
;
13800 digest
[3] -= SHA256M_D
;
13801 digest
[4] -= SHA256M_E
;
13802 digest
[5] -= SHA256M_F
;
13803 digest
[6] -= SHA256M_G
;
13804 digest
[7] -= SHA256M_H
;
13806 return (PARSER_OK
);
13809 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13811 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13813 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13815 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13817 u64
*digest
= (u64
*) hash_buf
->digest
;
13819 salt_t
*salt
= hash_buf
->salt
;
13821 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13823 char *iter_pos
= input_buf
+ 19;
13825 char *salt_pos
= strchr (iter_pos
, '.');
13827 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13831 char *hash_pos
= strchr (salt_pos
, '.');
13833 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13835 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13839 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13840 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13841 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13842 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13843 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13844 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13845 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13846 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13848 uint salt_len
= hash_pos
- salt_pos
- 1;
13852 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13856 for (i
= 0; i
< salt_len
; i
++)
13858 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13861 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13862 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13864 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13866 salt
->salt_len
= salt_len
;
13868 salt
->salt_iter
= atoi (iter_pos
) - 1;
13870 return (PARSER_OK
);
13873 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13875 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13877 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13879 u64
*digest
= (u64
*) hash_buf
->digest
;
13881 salt_t
*salt
= hash_buf
->salt
;
13883 u8 tmp_buf
[120] = { 0 };
13885 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13887 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13889 memcpy (digest
, tmp_buf
, 64);
13891 digest
[0] = byte_swap_64 (digest
[0]);
13892 digest
[1] = byte_swap_64 (digest
[1]);
13893 digest
[2] = byte_swap_64 (digest
[2]);
13894 digest
[3] = byte_swap_64 (digest
[3]);
13895 digest
[4] = byte_swap_64 (digest
[4]);
13896 digest
[5] = byte_swap_64 (digest
[5]);
13897 digest
[6] = byte_swap_64 (digest
[6]);
13898 digest
[7] = byte_swap_64 (digest
[7]);
13900 digest
[0] -= SHA512M_A
;
13901 digest
[1] -= SHA512M_B
;
13902 digest
[2] -= SHA512M_C
;
13903 digest
[3] -= SHA512M_D
;
13904 digest
[4] -= SHA512M_E
;
13905 digest
[5] -= SHA512M_F
;
13906 digest
[6] -= SHA512M_G
;
13907 digest
[7] -= SHA512M_H
;
13909 int salt_len
= tmp_len
- 64;
13911 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13913 salt
->salt_len
= salt_len
;
13915 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13917 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13919 char *ptr
= (char *) salt
->salt_buf
;
13921 ptr
[salt
->salt_len
] = 0x80;
13924 return (PARSER_OK
);
13927 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13929 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13931 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13935 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13938 u32
*digest
= (u32
*) hash_buf
->digest
;
13940 salt_t
*salt
= hash_buf
->salt
;
13942 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13943 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13944 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13945 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13947 digest
[0] = byte_swap_32 (digest
[0]);
13948 digest
[1] = byte_swap_32 (digest
[1]);
13949 digest
[2] = byte_swap_32 (digest
[2]);
13950 digest
[3] = byte_swap_32 (digest
[3]);
13952 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13954 uint salt_len
= input_len
- 32 - 1;
13956 char *salt_buf
= input_buf
+ 32 + 1;
13958 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13960 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13962 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13964 salt
->salt_len
= salt_len
;
13966 return (PARSER_OK
);
13969 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13971 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13973 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13977 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13980 u32
*digest
= (u32
*) hash_buf
->digest
;
13982 salt_t
*salt
= hash_buf
->salt
;
13984 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13985 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13986 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13987 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13988 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13990 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13992 uint salt_len
= input_len
- 40 - 1;
13994 char *salt_buf
= input_buf
+ 40 + 1;
13996 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13998 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14000 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14002 salt
->salt_len
= salt_len
;
14004 return (PARSER_OK
);
14007 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14009 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14011 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14015 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14018 u32
*digest
= (u32
*) hash_buf
->digest
;
14020 salt_t
*salt
= hash_buf
->salt
;
14022 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14023 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14024 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14025 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14026 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14027 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14028 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14029 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14031 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14033 uint salt_len
= input_len
- 64 - 1;
14035 char *salt_buf
= input_buf
+ 64 + 1;
14037 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14039 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14041 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14043 salt
->salt_len
= salt_len
;
14045 return (PARSER_OK
);
14048 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14050 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14052 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14056 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14059 u64
*digest
= (u64
*) hash_buf
->digest
;
14061 salt_t
*salt
= hash_buf
->salt
;
14063 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14064 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14065 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14066 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14067 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14068 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14069 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14070 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14072 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14074 uint salt_len
= input_len
- 128 - 1;
14076 char *salt_buf
= input_buf
+ 128 + 1;
14078 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14080 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14082 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14084 salt
->salt_len
= salt_len
;
14086 return (PARSER_OK
);
14089 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14091 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14093 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14095 u32
*digest
= (u32
*) hash_buf
->digest
;
14097 salt_t
*salt
= hash_buf
->salt
;
14099 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14105 char *user_pos
= input_buf
+ 10 + 1;
14107 char *realm_pos
= strchr (user_pos
, '$');
14109 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14111 uint user_len
= realm_pos
- user_pos
;
14113 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14117 char *salt_pos
= strchr (realm_pos
, '$');
14119 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14121 uint realm_len
= salt_pos
- realm_pos
;
14123 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14127 char *data_pos
= strchr (salt_pos
, '$');
14129 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14131 uint salt_len
= data_pos
- salt_pos
;
14133 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14137 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14139 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14145 memcpy (krb5pa
->user
, user_pos
, user_len
);
14146 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14147 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14149 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14151 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14153 const char p0
= data_pos
[i
+ 0];
14154 const char p1
= data_pos
[i
+ 1];
14156 *timestamp_ptr
++ = hex_convert (p1
) << 0
14157 | hex_convert (p0
) << 4;
14160 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14162 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14164 const char p0
= data_pos
[i
+ 0];
14165 const char p1
= data_pos
[i
+ 1];
14167 *checksum_ptr
++ = hex_convert (p1
) << 0
14168 | hex_convert (p0
) << 4;
14172 * copy some data to generic buffers to make sorting happy
14175 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14176 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14177 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14178 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14179 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14180 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14181 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14182 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14183 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14185 salt
->salt_len
= 36;
14187 digest
[0] = krb5pa
->checksum
[0];
14188 digest
[1] = krb5pa
->checksum
[1];
14189 digest
[2] = krb5pa
->checksum
[2];
14190 digest
[3] = krb5pa
->checksum
[3];
14192 return (PARSER_OK
);
14195 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14197 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14199 u32
*digest
= (u32
*) hash_buf
->digest
;
14201 salt_t
*salt
= hash_buf
->salt
;
14207 char *salt_pos
= input_buf
;
14209 char *hash_pos
= strchr (salt_pos
, '$');
14211 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14213 uint salt_len
= hash_pos
- salt_pos
;
14215 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14219 uint hash_len
= input_len
- 1 - salt_len
;
14221 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14229 for (uint i
= 0; i
< salt_len
; i
++)
14231 if (salt_pos
[i
] == ' ') continue;
14236 // SAP user names cannot be longer than 12 characters
14237 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14239 // SAP user name cannot start with ! or ?
14240 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14246 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14248 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14250 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14252 salt
->salt_len
= salt_len
;
14254 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14255 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14259 digest
[0] = byte_swap_32 (digest
[0]);
14260 digest
[1] = byte_swap_32 (digest
[1]);
14262 return (PARSER_OK
);
14265 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14267 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14269 u32
*digest
= (u32
*) hash_buf
->digest
;
14271 salt_t
*salt
= hash_buf
->salt
;
14277 char *salt_pos
= input_buf
;
14279 char *hash_pos
= strchr (salt_pos
, '$');
14281 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14283 uint salt_len
= hash_pos
- salt_pos
;
14285 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14289 uint hash_len
= input_len
- 1 - salt_len
;
14291 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14299 for (uint i
= 0; i
< salt_len
; i
++)
14301 if (salt_pos
[i
] == ' ') continue;
14306 // SAP user names cannot be longer than 12 characters
14307 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14308 // so far nobody complained so we stay with this because it helps in optimization
14309 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14311 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14313 // SAP user name cannot start with ! or ?
14314 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14320 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14322 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14324 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14326 salt
->salt_len
= salt_len
;
14328 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14329 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14330 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14331 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14332 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14334 return (PARSER_OK
);
14337 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14339 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14341 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14343 u64
*digest
= (u64
*) hash_buf
->digest
;
14345 salt_t
*salt
= hash_buf
->salt
;
14347 char *iter_pos
= input_buf
+ 3;
14349 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14351 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14353 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14355 salt
->salt_iter
= salt_iter
;
14357 char *salt_pos
= iter_pos
+ 1;
14361 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14363 salt
->salt_len
= salt_len
;
14365 char *hash_pos
= salt_pos
+ salt_len
;
14367 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14371 char *tmp
= (char *) salt
->salt_buf_pc
;
14373 tmp
[0] = hash_pos
[42];
14377 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14378 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14379 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14380 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14386 return (PARSER_OK
);
14389 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14391 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14393 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14395 u32
*digest
= (u32
*) hash_buf
->digest
;
14397 salt_t
*salt
= hash_buf
->salt
;
14399 char *salt_buf
= input_buf
+ 6;
14401 uint salt_len
= 16;
14403 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14405 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14407 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14409 salt
->salt_len
= salt_len
;
14411 char *hash_pos
= input_buf
+ 6 + 16;
14413 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14414 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14415 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14416 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14417 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14418 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14419 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14420 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14422 return (PARSER_OK
);
14425 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14427 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14429 u32
*digest
= (u32
*) hash_buf
->digest
;
14431 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14432 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14436 return (PARSER_OK
);
14439 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14441 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14443 u32
*digest
= (u32
*) hash_buf
->digest
;
14445 salt_t
*salt
= hash_buf
->salt
;
14447 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14449 char *saltbuf_pos
= input_buf
;
14451 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14453 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14455 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14457 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14458 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14460 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14464 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14466 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14468 char *salt_ptr
= (char *) saltbuf_pos
;
14469 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14474 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14476 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14479 rakp_ptr
[j
] = 0x80;
14481 rakp
->salt_len
= j
;
14483 for (i
= 0; i
< 64; i
++)
14485 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14488 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14489 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14490 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14491 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14492 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14493 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14494 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14495 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14497 salt
->salt_len
= 32; // muss min. 32 haben
14499 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14500 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14501 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14502 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14503 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14505 return (PARSER_OK
);
14508 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14510 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14512 u32
*digest
= (u32
*) hash_buf
->digest
;
14514 salt_t
*salt
= hash_buf
->salt
;
14516 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14518 char *salt_pos
= input_buf
+ 1;
14520 memcpy (salt
->salt_buf
, salt_pos
, 8);
14522 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14523 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14525 salt
->salt_len
= 8;
14527 char *hash_pos
= salt_pos
+ 8;
14529 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14530 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14531 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14532 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14533 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14535 digest
[0] -= SHA1M_A
;
14536 digest
[1] -= SHA1M_B
;
14537 digest
[2] -= SHA1M_C
;
14538 digest
[3] -= SHA1M_D
;
14539 digest
[4] -= SHA1M_E
;
14541 return (PARSER_OK
);
14544 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14546 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14548 u32
*digest
= (u32
*) hash_buf
->digest
;
14550 salt_t
*salt
= hash_buf
->salt
;
14552 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14553 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14554 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14555 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14557 digest
[0] = byte_swap_32 (digest
[0]);
14558 digest
[1] = byte_swap_32 (digest
[1]);
14559 digest
[2] = byte_swap_32 (digest
[2]);
14560 digest
[3] = byte_swap_32 (digest
[3]);
14562 digest
[0] -= MD5M_A
;
14563 digest
[1] -= MD5M_B
;
14564 digest
[2] -= MD5M_C
;
14565 digest
[3] -= MD5M_D
;
14567 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14569 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14571 u32
*salt_buf
= salt
->salt_buf
;
14573 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14574 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14575 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14576 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14578 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14579 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14580 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14581 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14583 salt
->salt_len
= 16 + 1;
14585 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14587 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14589 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14591 return (PARSER_OK
);
14594 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14596 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14598 u32
*digest
= (u32
*) hash_buf
->digest
;
14600 salt_t
*salt
= hash_buf
->salt
;
14602 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14608 char *hashbuf_pos
= input_buf
;
14610 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14612 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14614 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14616 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14620 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14622 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14624 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14626 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14630 char *databuf_pos
= strchr (iteration_pos
, ':');
14632 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14634 const uint iteration_len
= databuf_pos
- iteration_pos
;
14636 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14637 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14639 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14641 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14642 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14648 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14649 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14650 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14651 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14652 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14653 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14654 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14655 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14659 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14661 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14663 const char p0
= saltbuf_pos
[i
+ 0];
14664 const char p1
= saltbuf_pos
[i
+ 1];
14666 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14667 | hex_convert (p0
) << 4;
14670 salt
->salt_buf
[4] = 0x01000000;
14671 salt
->salt_buf
[5] = 0x80;
14673 salt
->salt_len
= saltbuf_len
/ 2;
14677 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14681 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14683 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14685 const char p0
= databuf_pos
[i
+ 0];
14686 const char p1
= databuf_pos
[i
+ 1];
14688 *databuf_ptr
++ = hex_convert (p1
) << 0
14689 | hex_convert (p0
) << 4;
14692 *databuf_ptr
++ = 0x80;
14694 for (uint i
= 0; i
< 512; i
++)
14696 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14699 cloudkey
->data_len
= databuf_len
/ 2;
14701 return (PARSER_OK
);
14704 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14706 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14708 u32
*digest
= (u32
*) hash_buf
->digest
;
14710 salt_t
*salt
= hash_buf
->salt
;
14716 char *hashbuf_pos
= input_buf
;
14718 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14720 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14722 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14724 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14728 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14730 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14732 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14734 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14736 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14740 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14742 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14744 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14746 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14748 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14752 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14754 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14755 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14757 // ok, the plan for this algorithm is the following:
14758 // we have 2 salts here, the domain-name and a random salt
14759 // while both are used in the initial transformation,
14760 // only the random salt is used in the following iterations
14761 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14762 // and one that includes only the real salt (stored into salt_buf[]).
14763 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14765 u8 tmp_buf
[100] = { 0 };
14767 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14769 memcpy (digest
, tmp_buf
, 20);
14771 digest
[0] = byte_swap_32 (digest
[0]);
14772 digest
[1] = byte_swap_32 (digest
[1]);
14773 digest
[2] = byte_swap_32 (digest
[2]);
14774 digest
[3] = byte_swap_32 (digest
[3]);
14775 digest
[4] = byte_swap_32 (digest
[4]);
14779 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14781 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14783 char *len_ptr
= NULL
;
14785 for (uint i
= 0; i
< domainbuf_len
; i
++)
14787 if (salt_buf_pc_ptr
[i
] == '.')
14789 len_ptr
= &salt_buf_pc_ptr
[i
];
14799 salt
->salt_buf_pc
[7] = domainbuf_len
;
14803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14805 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14807 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14809 salt
->salt_len
= salt_len
;
14813 salt
->salt_iter
= atoi (iteration_pos
);
14815 return (PARSER_OK
);
14818 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14820 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14822 u32
*digest
= (u32
*) hash_buf
->digest
;
14824 salt_t
*salt
= hash_buf
->salt
;
14826 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14827 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14828 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14829 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14830 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14832 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14834 uint salt_len
= input_len
- 40 - 1;
14836 char *salt_buf
= input_buf
+ 40 + 1;
14838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14840 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14842 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14844 salt
->salt_len
= salt_len
;
14846 return (PARSER_OK
);
14849 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14851 const u8 ascii_to_ebcdic
[] =
14853 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14854 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14855 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14856 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14857 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14858 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14859 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14860 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14861 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14862 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14863 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14864 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14865 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14866 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14867 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14868 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14871 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14873 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14875 u32
*digest
= (u32
*) hash_buf
->digest
;
14877 salt_t
*salt
= hash_buf
->salt
;
14879 char *salt_pos
= input_buf
+ 6 + 1;
14881 char *digest_pos
= strchr (salt_pos
, '*');
14883 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14885 uint salt_len
= digest_pos
- salt_pos
;
14887 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14889 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14891 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14895 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14896 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14898 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14900 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14902 salt
->salt_len
= salt_len
;
14904 for (uint i
= 0; i
< salt_len
; i
++)
14906 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14908 for (uint i
= salt_len
; i
< 8; i
++)
14910 salt_buf_pc_ptr
[i
] = 0x40;
14915 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14917 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14918 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14920 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14921 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14923 digest
[0] = byte_swap_32 (digest
[0]);
14924 digest
[1] = byte_swap_32 (digest
[1]);
14926 IP (digest
[0], digest
[1], tt
);
14928 digest
[0] = rotr32 (digest
[0], 29);
14929 digest
[1] = rotr32 (digest
[1], 29);
14933 return (PARSER_OK
);
14936 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14938 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14940 u32
*digest
= (u32
*) hash_buf
->digest
;
14942 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14943 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14944 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14945 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14947 digest
[0] = byte_swap_32 (digest
[0]);
14948 digest
[1] = byte_swap_32 (digest
[1]);
14949 digest
[2] = byte_swap_32 (digest
[2]);
14950 digest
[3] = byte_swap_32 (digest
[3]);
14952 return (PARSER_OK
);
14955 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14957 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14959 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14961 u32
*digest
= (u32
*) hash_buf
->digest
;
14963 salt_t
*salt
= hash_buf
->salt
;
14965 u8 tmp_buf
[120] = { 0 };
14967 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14969 tmp_buf
[3] += -4; // dont ask!
14971 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14973 salt
->salt_len
= 5;
14975 memcpy (digest
, tmp_buf
+ 5, 9);
14977 // yes, only 9 byte are needed to crack, but 10 to display
14979 salt
->salt_buf_pc
[7] = input_buf
[20];
14981 return (PARSER_OK
);
14984 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14986 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14988 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14990 u32
*digest
= (u32
*) hash_buf
->digest
;
14992 salt_t
*salt
= hash_buf
->salt
;
14994 u8 tmp_buf
[120] = { 0 };
14996 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14998 tmp_buf
[3] += -4; // dont ask!
15002 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15004 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)
15008 char tmp_iter_buf
[11] = { 0 };
15010 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15012 tmp_iter_buf
[10] = 0;
15014 salt
->salt_iter
= atoi (tmp_iter_buf
);
15016 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15018 return (PARSER_SALT_ITERATION
);
15021 salt
->salt_iter
--; // first round in init
15023 // 2 additional bytes for display only
15025 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15026 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15030 memcpy (digest
, tmp_buf
+ 28, 8);
15032 digest
[0] = byte_swap_32 (digest
[0]);
15033 digest
[1] = byte_swap_32 (digest
[1]);
15037 return (PARSER_OK
);
15040 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15042 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15044 u32
*digest
= (u32
*) hash_buf
->digest
;
15046 salt_t
*salt
= hash_buf
->salt
;
15048 char *salt_buf_pos
= input_buf
;
15050 char *hash_buf_pos
= salt_buf_pos
+ 6;
15052 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15053 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15054 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15055 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15056 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15057 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15058 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15059 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15061 digest
[0] -= SHA256M_A
;
15062 digest
[1] -= SHA256M_B
;
15063 digest
[2] -= SHA256M_C
;
15064 digest
[3] -= SHA256M_D
;
15065 digest
[4] -= SHA256M_E
;
15066 digest
[5] -= SHA256M_F
;
15067 digest
[6] -= SHA256M_G
;
15068 digest
[7] -= SHA256M_H
;
15070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15072 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15076 salt
->salt_len
= salt_len
;
15078 return (PARSER_OK
);
15081 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15083 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15085 u32
*digest
= (u32
*) hash_buf
->digest
;
15087 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15089 salt_t
*salt
= hash_buf
->salt
;
15091 char *salt_buf
= input_buf
+ 6;
15093 char *digest_buf
= strchr (salt_buf
, '$');
15095 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15097 uint salt_len
= digest_buf
- salt_buf
;
15099 digest_buf
++; // skip the '$' symbol
15101 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15103 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15105 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15107 salt
->salt_len
= salt_len
;
15109 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15110 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15111 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15112 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15114 digest
[0] = byte_swap_32 (digest
[0]);
15115 digest
[1] = byte_swap_32 (digest
[1]);
15116 digest
[2] = byte_swap_32 (digest
[2]);
15117 digest
[3] = byte_swap_32 (digest
[3]);
15119 digest
[0] -= MD5M_A
;
15120 digest
[1] -= MD5M_B
;
15121 digest
[2] -= MD5M_C
;
15122 digest
[3] -= MD5M_D
;
15124 return (PARSER_OK
);
15127 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15129 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15131 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15133 u32
*digest
= (u32
*) hash_buf
->digest
;
15135 salt_t
*salt
= hash_buf
->salt
;
15137 char *salt_buf
= input_buf
+ 3;
15139 char *digest_buf
= strchr (salt_buf
, '$');
15141 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15143 uint salt_len
= digest_buf
- salt_buf
;
15145 digest_buf
++; // skip the '$' symbol
15147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15149 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15151 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15153 salt_buf_ptr
[salt_len
] = 0x2d;
15155 salt
->salt_len
= salt_len
+ 1;
15157 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15158 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15159 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15160 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15162 digest
[0] = byte_swap_32 (digest
[0]);
15163 digest
[1] = byte_swap_32 (digest
[1]);
15164 digest
[2] = byte_swap_32 (digest
[2]);
15165 digest
[3] = byte_swap_32 (digest
[3]);
15167 digest
[0] -= MD5M_A
;
15168 digest
[1] -= MD5M_B
;
15169 digest
[2] -= MD5M_C
;
15170 digest
[3] -= MD5M_D
;
15172 return (PARSER_OK
);
15175 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15177 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15179 u32
*digest
= (u32
*) hash_buf
->digest
;
15181 salt_t
*salt
= hash_buf
->salt
;
15183 u8 tmp_buf
[100] = { 0 };
15185 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15187 memcpy (digest
, tmp_buf
, 20);
15189 digest
[0] = byte_swap_32 (digest
[0]);
15190 digest
[1] = byte_swap_32 (digest
[1]);
15191 digest
[2] = byte_swap_32 (digest
[2]);
15192 digest
[3] = byte_swap_32 (digest
[3]);
15193 digest
[4] = byte_swap_32 (digest
[4]);
15195 digest
[0] -= SHA1M_A
;
15196 digest
[1] -= SHA1M_B
;
15197 digest
[2] -= SHA1M_C
;
15198 digest
[3] -= SHA1M_D
;
15199 digest
[4] -= SHA1M_E
;
15201 salt
->salt_buf
[0] = 0x80;
15203 salt
->salt_len
= 0;
15205 return (PARSER_OK
);
15208 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15210 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15212 u32
*digest
= (u32
*) hash_buf
->digest
;
15214 salt_t
*salt
= hash_buf
->salt
;
15216 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15217 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15218 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15219 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15221 digest
[0] = byte_swap_32 (digest
[0]);
15222 digest
[1] = byte_swap_32 (digest
[1]);
15223 digest
[2] = byte_swap_32 (digest
[2]);
15224 digest
[3] = byte_swap_32 (digest
[3]);
15226 digest
[0] -= MD5M_A
;
15227 digest
[1] -= MD5M_B
;
15228 digest
[2] -= MD5M_C
;
15229 digest
[3] -= MD5M_D
;
15231 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15233 uint salt_len
= input_len
- 32 - 1;
15235 char *salt_buf
= input_buf
+ 32 + 1;
15237 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15239 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15241 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15244 * add static "salt" part
15247 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15251 salt
->salt_len
= salt_len
;
15253 return (PARSER_OK
);
15256 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15258 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15260 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15262 u32
*digest
= (u32
*) hash_buf
->digest
;
15264 salt_t
*salt
= hash_buf
->salt
;
15266 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15272 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15274 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15276 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15278 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15280 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15284 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15286 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15288 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15290 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15294 char *keybuf_pos
= strchr (keylen_pos
, '$');
15296 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15298 uint keylen_len
= keybuf_pos
- keylen_pos
;
15300 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15304 char *databuf_pos
= strchr (keybuf_pos
, '$');
15306 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15308 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15310 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15314 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15316 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15322 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15323 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15324 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15325 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15327 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15328 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15329 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15330 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15332 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15333 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15334 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15335 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15337 salt
->salt_len
= 16;
15338 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15340 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15342 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15345 return (PARSER_OK
);
15348 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15350 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15352 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15354 u32
*digest
= (u32
*) hash_buf
->digest
;
15356 salt_t
*salt
= hash_buf
->salt
;
15362 // first is the N salt parameter
15364 char *N_pos
= input_buf
+ 6;
15366 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15370 salt
->scrypt_N
= atoi (N_pos
);
15374 char *r_pos
= strchr (N_pos
, ':');
15376 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15380 salt
->scrypt_r
= atoi (r_pos
);
15384 char *p_pos
= strchr (r_pos
, ':');
15386 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15390 salt
->scrypt_p
= atoi (p_pos
);
15394 char *saltbuf_pos
= strchr (p_pos
, ':');
15396 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15400 char *hash_pos
= strchr (saltbuf_pos
, ':');
15402 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15408 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15410 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15412 u8 tmp_buf
[33] = { 0 };
15414 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15416 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15418 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15420 salt
->salt_len
= tmp_len
;
15421 salt
->salt_iter
= 1;
15423 // digest - base64 decode
15425 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15427 tmp_len
= input_len
- (hash_pos
- input_buf
);
15429 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15431 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15433 memcpy (digest
, tmp_buf
, 32);
15435 return (PARSER_OK
);
15438 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15440 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15442 u32
*digest
= (u32
*) hash_buf
->digest
;
15444 salt_t
*salt
= hash_buf
->salt
;
15450 char decrypted
[76] = { 0 }; // iv + hash
15452 juniper_decrypt_hash (input_buf
, decrypted
);
15454 char *md5crypt_hash
= decrypted
+ 12;
15456 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15458 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15460 char *salt_pos
= md5crypt_hash
+ 3;
15462 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15464 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15466 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15470 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15472 return (PARSER_OK
);
15475 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15477 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15479 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15481 u32
*digest
= (u32
*) hash_buf
->digest
;
15483 salt_t
*salt
= hash_buf
->salt
;
15485 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15491 // first is *raw* salt
15493 char *salt_pos
= input_buf
+ 3;
15495 char *hash_pos
= strchr (salt_pos
, '$');
15497 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 uint salt_len
= hash_pos
- salt_pos
;
15501 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15505 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15507 memcpy (salt_buf_ptr
, salt_pos
, 14);
15509 salt_buf_ptr
[17] = 0x01;
15510 salt_buf_ptr
[18] = 0x80;
15512 // add some stuff to normal salt to make sorted happy
15514 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15515 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15516 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15517 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15519 salt
->salt_len
= salt_len
;
15520 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15522 // base64 decode hash
15524 u8 tmp_buf
[100] = { 0 };
15526 uint hash_len
= input_len
- 3 - salt_len
- 1;
15528 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15530 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15532 memcpy (digest
, tmp_buf
, 32);
15534 digest
[0] = byte_swap_32 (digest
[0]);
15535 digest
[1] = byte_swap_32 (digest
[1]);
15536 digest
[2] = byte_swap_32 (digest
[2]);
15537 digest
[3] = byte_swap_32 (digest
[3]);
15538 digest
[4] = byte_swap_32 (digest
[4]);
15539 digest
[5] = byte_swap_32 (digest
[5]);
15540 digest
[6] = byte_swap_32 (digest
[6]);
15541 digest
[7] = byte_swap_32 (digest
[7]);
15543 return (PARSER_OK
);
15546 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15548 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15550 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15552 u32
*digest
= (u32
*) hash_buf
->digest
;
15554 salt_t
*salt
= hash_buf
->salt
;
15560 // first is *raw* salt
15562 char *salt_pos
= input_buf
+ 3;
15564 char *hash_pos
= strchr (salt_pos
, '$');
15566 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15568 uint salt_len
= hash_pos
- salt_pos
;
15570 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15572 salt
->salt_len
= salt_len
;
15575 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15577 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15578 salt_buf_ptr
[salt_len
] = 0;
15580 // base64 decode hash
15582 u8 tmp_buf
[100] = { 0 };
15584 uint hash_len
= input_len
- 3 - salt_len
- 1;
15586 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15588 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15590 memcpy (digest
, tmp_buf
, 32);
15593 salt
->scrypt_N
= 16384;
15594 salt
->scrypt_r
= 1;
15595 salt
->scrypt_p
= 1;
15596 salt
->salt_iter
= 1;
15598 return (PARSER_OK
);
15601 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15603 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15605 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15607 u32
*digest
= (u32
*) hash_buf
->digest
;
15609 salt_t
*salt
= hash_buf
->salt
;
15611 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15617 char *version_pos
= input_buf
+ 8 + 1;
15619 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15621 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15623 u32 version_len
= verifierHashSize_pos
- version_pos
;
15625 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15627 verifierHashSize_pos
++;
15629 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15631 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15633 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15635 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15639 char *saltSize_pos
= strchr (keySize_pos
, '*');
15641 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15643 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15645 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15649 char *osalt_pos
= strchr (saltSize_pos
, '*');
15651 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15653 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15655 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15659 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15661 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15663 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15665 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15667 encryptedVerifier_pos
++;
15669 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15671 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15673 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15675 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15677 encryptedVerifierHash_pos
++;
15679 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;
15681 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15683 const uint version
= atoi (version_pos
);
15685 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15687 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15689 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15691 const uint keySize
= atoi (keySize_pos
);
15693 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15695 office2007
->keySize
= keySize
;
15697 const uint saltSize
= atoi (saltSize_pos
);
15699 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15705 salt
->salt_len
= 16;
15706 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15708 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15709 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15710 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15711 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15717 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15718 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15719 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15720 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15722 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15723 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15724 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15725 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15726 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15732 digest
[0] = office2007
->encryptedVerifierHash
[0];
15733 digest
[1] = office2007
->encryptedVerifierHash
[1];
15734 digest
[2] = office2007
->encryptedVerifierHash
[2];
15735 digest
[3] = office2007
->encryptedVerifierHash
[3];
15737 return (PARSER_OK
);
15740 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15742 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15744 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15746 u32
*digest
= (u32
*) hash_buf
->digest
;
15748 salt_t
*salt
= hash_buf
->salt
;
15750 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15756 char *version_pos
= input_buf
+ 8 + 1;
15758 char *spinCount_pos
= strchr (version_pos
, '*');
15760 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15762 u32 version_len
= spinCount_pos
- version_pos
;
15764 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15768 char *keySize_pos
= strchr (spinCount_pos
, '*');
15770 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15772 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15774 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15778 char *saltSize_pos
= strchr (keySize_pos
, '*');
15780 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15782 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15784 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15788 char *osalt_pos
= strchr (saltSize_pos
, '*');
15790 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15792 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15794 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15798 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15800 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15802 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15804 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15806 encryptedVerifier_pos
++;
15808 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15810 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15812 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15814 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15816 encryptedVerifierHash_pos
++;
15818 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;
15820 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15822 const uint version
= atoi (version_pos
);
15824 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15826 const uint spinCount
= atoi (spinCount_pos
);
15828 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15830 const uint keySize
= atoi (keySize_pos
);
15832 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15834 const uint saltSize
= atoi (saltSize_pos
);
15836 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15842 salt
->salt_len
= 16;
15843 salt
->salt_iter
= spinCount
;
15845 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15846 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15847 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15848 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15854 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15855 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15856 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15857 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15859 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15860 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15861 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15862 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15863 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15864 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15865 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15866 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15872 digest
[0] = office2010
->encryptedVerifierHash
[0];
15873 digest
[1] = office2010
->encryptedVerifierHash
[1];
15874 digest
[2] = office2010
->encryptedVerifierHash
[2];
15875 digest
[3] = office2010
->encryptedVerifierHash
[3];
15877 return (PARSER_OK
);
15880 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15882 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15884 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15886 u32
*digest
= (u32
*) hash_buf
->digest
;
15888 salt_t
*salt
= hash_buf
->salt
;
15890 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15896 char *version_pos
= input_buf
+ 8 + 1;
15898 char *spinCount_pos
= strchr (version_pos
, '*');
15900 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15902 u32 version_len
= spinCount_pos
- version_pos
;
15904 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15908 char *keySize_pos
= strchr (spinCount_pos
, '*');
15910 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15912 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15914 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15918 char *saltSize_pos
= strchr (keySize_pos
, '*');
15920 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15922 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15924 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15928 char *osalt_pos
= strchr (saltSize_pos
, '*');
15930 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15932 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15934 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15938 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15940 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15942 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15944 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15946 encryptedVerifier_pos
++;
15948 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15950 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15952 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15954 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15956 encryptedVerifierHash_pos
++;
15958 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;
15960 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15962 const uint version
= atoi (version_pos
);
15964 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15966 const uint spinCount
= atoi (spinCount_pos
);
15968 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15970 const uint keySize
= atoi (keySize_pos
);
15972 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15974 const uint saltSize
= atoi (saltSize_pos
);
15976 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15982 salt
->salt_len
= 16;
15983 salt
->salt_iter
= spinCount
;
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]);
15994 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15995 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15996 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15997 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15999 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16000 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16001 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16002 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16003 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16004 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16005 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16006 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16012 digest
[0] = office2013
->encryptedVerifierHash
[0];
16013 digest
[1] = office2013
->encryptedVerifierHash
[1];
16014 digest
[2] = office2013
->encryptedVerifierHash
[2];
16015 digest
[3] = office2013
->encryptedVerifierHash
[3];
16017 return (PARSER_OK
);
16020 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16022 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16024 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16026 u32
*digest
= (u32
*) hash_buf
->digest
;
16028 salt_t
*salt
= hash_buf
->salt
;
16030 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16036 char *version_pos
= input_buf
+ 11;
16038 char *osalt_pos
= strchr (version_pos
, '*');
16040 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16042 u32 version_len
= osalt_pos
- version_pos
;
16044 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16048 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16050 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16052 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16054 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16056 encryptedVerifier_pos
++;
16058 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16060 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16062 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16064 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16066 encryptedVerifierHash_pos
++;
16068 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16070 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16072 const uint version
= *version_pos
- 0x30;
16074 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16080 oldoffice01
->version
= version
;
16082 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16083 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16084 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16085 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16087 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16088 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16089 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16090 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16092 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16093 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16094 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16095 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16097 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16098 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16099 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16100 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16106 salt
->salt_len
= 16;
16108 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16109 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16110 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16111 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16113 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16114 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16115 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16116 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16118 // this is a workaround as office produces multiple documents with the same salt
16120 salt
->salt_len
+= 32;
16122 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16123 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16124 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16125 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16126 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16127 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16128 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16129 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16135 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16136 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16137 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16138 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16140 return (PARSER_OK
);
16143 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16145 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16148 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16150 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16152 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16154 u32
*digest
= (u32
*) hash_buf
->digest
;
16156 salt_t
*salt
= hash_buf
->salt
;
16158 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16164 char *version_pos
= input_buf
+ 11;
16166 char *osalt_pos
= strchr (version_pos
, '*');
16168 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 u32 version_len
= osalt_pos
- version_pos
;
16172 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16176 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16178 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16180 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16182 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16184 encryptedVerifier_pos
++;
16186 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16188 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16190 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16192 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16194 encryptedVerifierHash_pos
++;
16196 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16198 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16200 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16202 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16206 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16208 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16210 const uint version
= *version_pos
- 0x30;
16212 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16218 oldoffice01
->version
= version
;
16220 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16221 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16222 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16223 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16225 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16226 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16227 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16228 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16230 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16231 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16232 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16233 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16235 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16236 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16237 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16238 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16240 oldoffice01
->rc4key
[1] = 0;
16241 oldoffice01
->rc4key
[0] = 0;
16243 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16244 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16245 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16246 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16247 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16248 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16249 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16250 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16251 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16252 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16254 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16255 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16261 salt
->salt_len
= 16;
16263 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16264 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16265 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16266 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16268 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16269 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16270 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16271 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16273 // this is a workaround as office produces multiple documents with the same salt
16275 salt
->salt_len
+= 32;
16277 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16278 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16279 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16280 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16281 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16282 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16283 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16284 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16290 digest
[0] = oldoffice01
->rc4key
[0];
16291 digest
[1] = oldoffice01
->rc4key
[1];
16295 return (PARSER_OK
);
16298 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16300 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16302 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16304 u32
*digest
= (u32
*) hash_buf
->digest
;
16306 salt_t
*salt
= hash_buf
->salt
;
16308 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16314 char *version_pos
= input_buf
+ 11;
16316 char *osalt_pos
= strchr (version_pos
, '*');
16318 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16320 u32 version_len
= osalt_pos
- version_pos
;
16322 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16326 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16328 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16330 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16332 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16334 encryptedVerifier_pos
++;
16336 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16338 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16340 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16342 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16344 encryptedVerifierHash_pos
++;
16346 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16348 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16350 const uint version
= *version_pos
- 0x30;
16352 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16358 oldoffice34
->version
= version
;
16360 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16361 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16362 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16363 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16365 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16366 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16367 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16368 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16370 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16371 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16372 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16373 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16374 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16376 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16377 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16378 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16379 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16380 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16386 salt
->salt_len
= 16;
16388 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16389 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16390 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16391 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16393 // this is a workaround as office produces multiple documents with the same salt
16395 salt
->salt_len
+= 32;
16397 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16398 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16399 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16400 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16401 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16402 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16403 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16404 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16410 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16411 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16412 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16413 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16415 return (PARSER_OK
);
16418 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16420 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16422 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16425 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16427 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16429 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16431 u32
*digest
= (u32
*) hash_buf
->digest
;
16433 salt_t
*salt
= hash_buf
->salt
;
16435 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16441 char *version_pos
= input_buf
+ 11;
16443 char *osalt_pos
= strchr (version_pos
, '*');
16445 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16447 u32 version_len
= osalt_pos
- version_pos
;
16449 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16453 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16455 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16457 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16459 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16461 encryptedVerifier_pos
++;
16463 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16465 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16467 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16469 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16471 encryptedVerifierHash_pos
++;
16473 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16475 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16479 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16483 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16485 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16487 const uint version
= *version_pos
- 0x30;
16489 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16495 oldoffice34
->version
= version
;
16497 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16498 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16499 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16500 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16502 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16503 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16504 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16505 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16507 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16508 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16509 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16510 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16511 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16513 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16514 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16515 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16516 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16517 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16519 oldoffice34
->rc4key
[1] = 0;
16520 oldoffice34
->rc4key
[0] = 0;
16522 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16523 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16524 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16525 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16526 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16527 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16528 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16529 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16530 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16531 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16533 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16534 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16540 salt
->salt_len
= 16;
16542 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16543 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16544 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16545 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16547 // this is a workaround as office produces multiple documents with the same salt
16549 salt
->salt_len
+= 32;
16551 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16552 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16553 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16554 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16555 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16556 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16557 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16558 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16564 digest
[0] = oldoffice34
->rc4key
[0];
16565 digest
[1] = oldoffice34
->rc4key
[1];
16569 return (PARSER_OK
);
16572 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16574 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16576 u32
*digest
= (u32
*) hash_buf
->digest
;
16578 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16579 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16580 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16581 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16583 digest
[0] = byte_swap_32 (digest
[0]);
16584 digest
[1] = byte_swap_32 (digest
[1]);
16585 digest
[2] = byte_swap_32 (digest
[2]);
16586 digest
[3] = byte_swap_32 (digest
[3]);
16588 return (PARSER_OK
);
16591 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16593 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16595 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16597 u32
*digest
= (u32
*) hash_buf
->digest
;
16599 salt_t
*salt
= hash_buf
->salt
;
16601 char *signature_pos
= input_buf
;
16603 char *salt_pos
= strchr (signature_pos
, '$');
16605 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16607 u32 signature_len
= salt_pos
- signature_pos
;
16609 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16613 char *hash_pos
= strchr (salt_pos
, '$');
16615 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16617 u32 salt_len
= hash_pos
- salt_pos
;
16619 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16623 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16625 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16627 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16628 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16629 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16630 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16631 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16633 digest
[0] -= SHA1M_A
;
16634 digest
[1] -= SHA1M_B
;
16635 digest
[2] -= SHA1M_C
;
16636 digest
[3] -= SHA1M_D
;
16637 digest
[4] -= SHA1M_E
;
16639 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16641 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16643 salt
->salt_len
= salt_len
;
16645 return (PARSER_OK
);
16648 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16650 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16652 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16654 u32
*digest
= (u32
*) hash_buf
->digest
;
16656 salt_t
*salt
= hash_buf
->salt
;
16658 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16664 char *iter_pos
= input_buf
+ 14;
16666 const int iter
= atoi (iter_pos
);
16668 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16670 salt
->salt_iter
= iter
- 1;
16672 char *salt_pos
= strchr (iter_pos
, '$');
16674 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16678 char *hash_pos
= strchr (salt_pos
, '$');
16680 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16682 const uint salt_len
= hash_pos
- salt_pos
;
16686 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16688 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16690 salt
->salt_len
= salt_len
;
16692 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16693 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16695 // add some stuff to normal salt to make sorted happy
16697 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16698 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16699 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16700 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16701 salt
->salt_buf
[4] = salt
->salt_iter
;
16703 // base64 decode hash
16705 u8 tmp_buf
[100] = { 0 };
16707 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16709 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16711 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16713 memcpy (digest
, tmp_buf
, 32);
16715 digest
[0] = byte_swap_32 (digest
[0]);
16716 digest
[1] = byte_swap_32 (digest
[1]);
16717 digest
[2] = byte_swap_32 (digest
[2]);
16718 digest
[3] = byte_swap_32 (digest
[3]);
16719 digest
[4] = byte_swap_32 (digest
[4]);
16720 digest
[5] = byte_swap_32 (digest
[5]);
16721 digest
[6] = byte_swap_32 (digest
[6]);
16722 digest
[7] = byte_swap_32 (digest
[7]);
16724 return (PARSER_OK
);
16727 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16729 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16731 u32
*digest
= (u32
*) hash_buf
->digest
;
16733 salt_t
*salt
= hash_buf
->salt
;
16735 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16736 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16740 digest
[0] = byte_swap_32 (digest
[0]);
16741 digest
[1] = byte_swap_32 (digest
[1]);
16743 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16744 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16745 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16747 char iter_c
= input_buf
[17];
16748 char iter_d
= input_buf
[19];
16750 // atm only defaults, let's see if there's more request
16751 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16752 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16754 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16756 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16757 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16758 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16759 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16761 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16762 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16763 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16764 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16766 salt
->salt_len
= 16;
16768 return (PARSER_OK
);
16771 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16773 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16775 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16777 u32
*digest
= (u32
*) hash_buf
->digest
;
16779 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16781 salt_t
*salt
= hash_buf
->salt
;
16783 char *salt_pos
= input_buf
+ 10;
16785 char *hash_pos
= strchr (salt_pos
, '$');
16787 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16789 uint salt_len
= hash_pos
- salt_pos
;
16793 uint hash_len
= input_len
- 10 - salt_len
- 1;
16795 // base64 decode salt
16797 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16799 u8 tmp_buf
[100] = { 0 };
16801 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16803 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16805 tmp_buf
[salt_len
] = 0x80;
16807 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16809 salt
->salt_len
= salt_len
;
16811 // base64 decode hash
16813 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16815 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16817 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16819 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16821 uint user_len
= hash_len
- 32;
16823 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16825 user_len
--; // skip the trailing space
16827 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16828 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16829 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16830 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16832 digest
[0] = byte_swap_32 (digest
[0]);
16833 digest
[1] = byte_swap_32 (digest
[1]);
16834 digest
[2] = byte_swap_32 (digest
[2]);
16835 digest
[3] = byte_swap_32 (digest
[3]);
16837 // store username for host only (output hash if cracked)
16839 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16840 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16842 return (PARSER_OK
);
16845 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16847 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16849 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16851 u32
*digest
= (u32
*) hash_buf
->digest
;
16853 salt_t
*salt
= hash_buf
->salt
;
16855 char *iter_pos
= input_buf
+ 10;
16857 u32 iter
= atoi (iter_pos
);
16861 return (PARSER_SALT_ITERATION
);
16864 iter
--; // first iteration is special
16866 salt
->salt_iter
= iter
;
16868 char *base64_pos
= strchr (iter_pos
, '}');
16870 if (base64_pos
== NULL
)
16872 return (PARSER_SIGNATURE_UNMATCHED
);
16877 // base64 decode salt
16879 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16881 u8 tmp_buf
[100] = { 0 };
16883 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16885 if (decoded_len
< 24)
16887 return (PARSER_SALT_LENGTH
);
16892 uint salt_len
= decoded_len
- 20;
16894 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16895 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16897 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16899 salt
->salt_len
= salt_len
;
16903 u32
*digest_ptr
= (u32
*) tmp_buf
;
16905 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16906 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16907 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16908 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16909 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16911 return (PARSER_OK
);
16914 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16916 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16918 u32
*digest
= (u32
*) hash_buf
->digest
;
16920 salt_t
*salt
= hash_buf
->salt
;
16922 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16923 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16924 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16925 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16926 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16928 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16930 uint salt_len
= input_len
- 40 - 1;
16932 char *salt_buf
= input_buf
+ 40 + 1;
16934 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16936 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16938 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16940 salt
->salt_len
= salt_len
;
16942 return (PARSER_OK
);
16945 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16947 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16949 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16951 u32
*digest
= (u32
*) hash_buf
->digest
;
16953 salt_t
*salt
= hash_buf
->salt
;
16955 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16961 char *V_pos
= input_buf
+ 5;
16963 char *R_pos
= strchr (V_pos
, '*');
16965 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16967 u32 V_len
= R_pos
- V_pos
;
16971 char *bits_pos
= strchr (R_pos
, '*');
16973 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16975 u32 R_len
= bits_pos
- R_pos
;
16979 char *P_pos
= strchr (bits_pos
, '*');
16981 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16983 u32 bits_len
= P_pos
- bits_pos
;
16987 char *enc_md_pos
= strchr (P_pos
, '*');
16989 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16991 u32 P_len
= enc_md_pos
- P_pos
;
16995 char *id_len_pos
= strchr (enc_md_pos
, '*');
16997 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16999 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17003 char *id_buf_pos
= strchr (id_len_pos
, '*');
17005 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17007 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17011 char *u_len_pos
= strchr (id_buf_pos
, '*');
17013 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17015 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17017 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17021 char *u_buf_pos
= strchr (u_len_pos
, '*');
17023 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17025 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17029 char *o_len_pos
= strchr (u_buf_pos
, '*');
17031 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17033 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17035 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17039 char *o_buf_pos
= strchr (o_len_pos
, '*');
17041 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17043 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17047 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;
17049 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17053 const int V
= atoi (V_pos
);
17054 const int R
= atoi (R_pos
);
17055 const int P
= atoi (P_pos
);
17057 if (V
!= 1) return (PARSER_SALT_VALUE
);
17058 if (R
!= 2) return (PARSER_SALT_VALUE
);
17060 const int enc_md
= atoi (enc_md_pos
);
17062 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17064 const int id_len
= atoi (id_len_pos
);
17065 const int u_len
= atoi (u_len_pos
);
17066 const int o_len
= atoi (o_len_pos
);
17068 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17069 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17070 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17072 const int bits
= atoi (bits_pos
);
17074 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17076 // copy data to esalt
17082 pdf
->enc_md
= enc_md
;
17084 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17085 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17086 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17087 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17088 pdf
->id_len
= id_len
;
17090 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17091 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17092 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17093 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17094 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17095 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17096 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17097 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17098 pdf
->u_len
= u_len
;
17100 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17101 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17102 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17103 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17104 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17105 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17106 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17107 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17108 pdf
->o_len
= o_len
;
17110 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17111 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17112 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17113 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17115 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17116 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17117 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17118 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17119 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17120 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17121 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17122 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17124 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17125 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17126 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17127 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17128 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17129 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17130 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17131 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17133 // we use ID for salt, maybe needs to change, we will see...
17135 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17136 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17137 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17138 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17139 salt
->salt_len
= pdf
->id_len
;
17141 digest
[0] = pdf
->u_buf
[0];
17142 digest
[1] = pdf
->u_buf
[1];
17143 digest
[2] = pdf
->u_buf
[2];
17144 digest
[3] = pdf
->u_buf
[3];
17146 return (PARSER_OK
);
17149 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17151 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17154 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17156 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17158 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17160 u32
*digest
= (u32
*) hash_buf
->digest
;
17162 salt_t
*salt
= hash_buf
->salt
;
17164 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17170 char *V_pos
= input_buf
+ 5;
17172 char *R_pos
= strchr (V_pos
, '*');
17174 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17176 u32 V_len
= R_pos
- V_pos
;
17180 char *bits_pos
= strchr (R_pos
, '*');
17182 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17184 u32 R_len
= bits_pos
- R_pos
;
17188 char *P_pos
= strchr (bits_pos
, '*');
17190 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17192 u32 bits_len
= P_pos
- bits_pos
;
17196 char *enc_md_pos
= strchr (P_pos
, '*');
17198 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17200 u32 P_len
= enc_md_pos
- P_pos
;
17204 char *id_len_pos
= strchr (enc_md_pos
, '*');
17206 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17208 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17212 char *id_buf_pos
= strchr (id_len_pos
, '*');
17214 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17216 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17220 char *u_len_pos
= strchr (id_buf_pos
, '*');
17222 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17224 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17226 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17230 char *u_buf_pos
= strchr (u_len_pos
, '*');
17232 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17234 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17238 char *o_len_pos
= strchr (u_buf_pos
, '*');
17240 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17242 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17244 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17248 char *o_buf_pos
= strchr (o_len_pos
, '*');
17250 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17252 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17256 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17258 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17260 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17262 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17266 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;
17268 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17272 const int V
= atoi (V_pos
);
17273 const int R
= atoi (R_pos
);
17274 const int P
= atoi (P_pos
);
17276 if (V
!= 1) return (PARSER_SALT_VALUE
);
17277 if (R
!= 2) return (PARSER_SALT_VALUE
);
17279 const int enc_md
= atoi (enc_md_pos
);
17281 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17283 const int id_len
= atoi (id_len_pos
);
17284 const int u_len
= atoi (u_len_pos
);
17285 const int o_len
= atoi (o_len_pos
);
17287 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17288 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17289 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17291 const int bits
= atoi (bits_pos
);
17293 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17295 // copy data to esalt
17301 pdf
->enc_md
= enc_md
;
17303 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17304 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17305 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17306 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17307 pdf
->id_len
= id_len
;
17309 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17310 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17311 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17312 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17313 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17314 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17315 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17316 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17317 pdf
->u_len
= u_len
;
17319 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17320 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17321 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17322 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17323 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17324 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17325 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17326 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17327 pdf
->o_len
= o_len
;
17329 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17330 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17331 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17332 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17334 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17335 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17336 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17337 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17338 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17339 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17340 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17341 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17343 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17344 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17345 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17346 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17347 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17348 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17349 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17350 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17352 pdf
->rc4key
[1] = 0;
17353 pdf
->rc4key
[0] = 0;
17355 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17356 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17357 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17358 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17359 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17360 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17361 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17362 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17363 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17364 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17366 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17367 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17369 // we use ID for salt, maybe needs to change, we will see...
17371 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17372 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17373 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17374 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17375 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17376 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17377 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17378 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17379 salt
->salt_len
= pdf
->id_len
+ 16;
17381 digest
[0] = pdf
->rc4key
[0];
17382 digest
[1] = pdf
->rc4key
[1];
17386 return (PARSER_OK
);
17389 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17391 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17393 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17395 u32
*digest
= (u32
*) hash_buf
->digest
;
17397 salt_t
*salt
= hash_buf
->salt
;
17399 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17405 char *V_pos
= input_buf
+ 5;
17407 char *R_pos
= strchr (V_pos
, '*');
17409 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17411 u32 V_len
= R_pos
- V_pos
;
17415 char *bits_pos
= strchr (R_pos
, '*');
17417 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17419 u32 R_len
= bits_pos
- R_pos
;
17423 char *P_pos
= strchr (bits_pos
, '*');
17425 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17427 u32 bits_len
= P_pos
- bits_pos
;
17431 char *enc_md_pos
= strchr (P_pos
, '*');
17433 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17435 u32 P_len
= enc_md_pos
- P_pos
;
17439 char *id_len_pos
= strchr (enc_md_pos
, '*');
17441 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17443 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17447 char *id_buf_pos
= strchr (id_len_pos
, '*');
17449 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17451 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17455 char *u_len_pos
= strchr (id_buf_pos
, '*');
17457 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17459 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17461 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17465 char *u_buf_pos
= strchr (u_len_pos
, '*');
17467 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17469 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17473 char *o_len_pos
= strchr (u_buf_pos
, '*');
17475 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17477 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17479 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17483 char *o_buf_pos
= strchr (o_len_pos
, '*');
17485 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17487 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17491 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;
17493 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17497 const int V
= atoi (V_pos
);
17498 const int R
= atoi (R_pos
);
17499 const int P
= atoi (P_pos
);
17503 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17504 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17506 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17508 const int id_len
= atoi (id_len_pos
);
17509 const int u_len
= atoi (u_len_pos
);
17510 const int o_len
= atoi (o_len_pos
);
17512 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17514 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17515 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17517 const int bits
= atoi (bits_pos
);
17519 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17525 enc_md
= atoi (enc_md_pos
);
17528 // copy data to esalt
17534 pdf
->enc_md
= enc_md
;
17536 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17537 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17538 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17539 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17543 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17544 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17545 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17546 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17549 pdf
->id_len
= id_len
;
17551 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17552 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17553 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17554 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17555 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17556 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17557 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17558 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17559 pdf
->u_len
= u_len
;
17561 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17562 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17563 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17564 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17565 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17566 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17567 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17568 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17569 pdf
->o_len
= o_len
;
17571 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17572 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17573 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17574 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17578 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17579 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17580 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17581 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17584 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17585 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17586 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17587 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17588 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17589 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17590 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17591 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17593 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17594 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17595 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17596 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17597 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17598 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17599 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17600 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17602 // precompute rc4 data for later use
17618 uint salt_pc_block
[32] = { 0 };
17620 char *salt_pc_ptr
= (char *) salt_pc_block
;
17622 memcpy (salt_pc_ptr
, padding
, 32);
17623 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17625 uint salt_pc_digest
[4] = { 0 };
17627 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17629 pdf
->rc4data
[0] = salt_pc_digest
[0];
17630 pdf
->rc4data
[1] = salt_pc_digest
[1];
17632 // we use ID for salt, maybe needs to change, we will see...
17634 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17635 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17636 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17637 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17638 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17639 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17640 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17641 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17642 salt
->salt_len
= pdf
->id_len
+ 16;
17644 salt
->salt_iter
= ROUNDS_PDF14
;
17646 digest
[0] = pdf
->u_buf
[0];
17647 digest
[1] = pdf
->u_buf
[1];
17651 return (PARSER_OK
);
17654 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17656 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17658 if (ret
!= PARSER_OK
)
17663 u32
*digest
= (u32
*) hash_buf
->digest
;
17665 salt_t
*salt
= hash_buf
->salt
;
17667 digest
[0] -= SHA256M_A
;
17668 digest
[1] -= SHA256M_B
;
17669 digest
[2] -= SHA256M_C
;
17670 digest
[3] -= SHA256M_D
;
17671 digest
[4] -= SHA256M_E
;
17672 digest
[5] -= SHA256M_F
;
17673 digest
[6] -= SHA256M_G
;
17674 digest
[7] -= SHA256M_H
;
17676 salt
->salt_buf
[2] = 0x80;
17678 return (PARSER_OK
);
17681 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17683 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17685 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17687 u32
*digest
= (u32
*) hash_buf
->digest
;
17689 salt_t
*salt
= hash_buf
->salt
;
17691 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17697 char *V_pos
= input_buf
+ 5;
17699 char *R_pos
= strchr (V_pos
, '*');
17701 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17703 u32 V_len
= R_pos
- V_pos
;
17707 char *bits_pos
= strchr (R_pos
, '*');
17709 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17711 u32 R_len
= bits_pos
- R_pos
;
17715 char *P_pos
= strchr (bits_pos
, '*');
17717 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17719 u32 bits_len
= P_pos
- bits_pos
;
17723 char *enc_md_pos
= strchr (P_pos
, '*');
17725 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17727 u32 P_len
= enc_md_pos
- P_pos
;
17731 char *id_len_pos
= strchr (enc_md_pos
, '*');
17733 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17735 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17739 char *id_buf_pos
= strchr (id_len_pos
, '*');
17741 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17743 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17747 char *u_len_pos
= strchr (id_buf_pos
, '*');
17749 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17751 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17755 char *u_buf_pos
= strchr (u_len_pos
, '*');
17757 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17759 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17763 char *o_len_pos
= strchr (u_buf_pos
, '*');
17765 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17767 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17771 char *o_buf_pos
= strchr (o_len_pos
, '*');
17773 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17775 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17779 char *last
= strchr (o_buf_pos
, '*');
17781 if (last
== NULL
) last
= input_buf
+ input_len
;
17783 u32 o_buf_len
= last
- o_buf_pos
;
17787 const int V
= atoi (V_pos
);
17788 const int R
= atoi (R_pos
);
17792 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17793 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17795 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17797 const int bits
= atoi (bits_pos
);
17799 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17801 int enc_md
= atoi (enc_md_pos
);
17803 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17805 const uint id_len
= atoi (id_len_pos
);
17806 const uint u_len
= atoi (u_len_pos
);
17807 const uint o_len
= atoi (o_len_pos
);
17809 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17810 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17811 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17812 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17813 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17814 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17815 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17816 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17818 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17819 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17820 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17822 // copy data to esalt
17824 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17826 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17828 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17831 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17832 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17834 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17835 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17837 salt
->salt_len
= 8;
17838 salt
->salt_iter
= ROUNDS_PDF17L8
;
17840 digest
[0] = pdf
->u_buf
[0];
17841 digest
[1] = pdf
->u_buf
[1];
17842 digest
[2] = pdf
->u_buf
[2];
17843 digest
[3] = pdf
->u_buf
[3];
17844 digest
[4] = pdf
->u_buf
[4];
17845 digest
[5] = pdf
->u_buf
[5];
17846 digest
[6] = pdf
->u_buf
[6];
17847 digest
[7] = pdf
->u_buf
[7];
17849 return (PARSER_OK
);
17852 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17854 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17856 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17858 u32
*digest
= (u32
*) hash_buf
->digest
;
17860 salt_t
*salt
= hash_buf
->salt
;
17862 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17870 char *iter_pos
= input_buf
+ 7;
17872 u32 iter
= atoi (iter_pos
);
17874 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17875 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17877 // first is *raw* salt
17879 char *salt_pos
= strchr (iter_pos
, ':');
17881 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17885 char *hash_pos
= strchr (salt_pos
, ':');
17887 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17889 u32 salt_len
= hash_pos
- salt_pos
;
17891 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17895 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17897 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17901 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17903 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17907 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17908 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17910 salt
->salt_len
= salt_len
;
17911 salt
->salt_iter
= iter
- 1;
17915 u8 tmp_buf
[100] = { 0 };
17917 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17919 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17921 memcpy (digest
, tmp_buf
, 16);
17923 digest
[0] = byte_swap_32 (digest
[0]);
17924 digest
[1] = byte_swap_32 (digest
[1]);
17925 digest
[2] = byte_swap_32 (digest
[2]);
17926 digest
[3] = byte_swap_32 (digest
[3]);
17928 // add some stuff to normal salt to make sorted happy
17930 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17931 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17932 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17933 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17934 salt
->salt_buf
[4] = salt
->salt_iter
;
17936 return (PARSER_OK
);
17939 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17941 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17943 u32
*digest
= (u32
*) hash_buf
->digest
;
17945 salt_t
*salt
= hash_buf
->salt
;
17947 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17948 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17949 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17950 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17952 digest
[0] = byte_swap_32 (digest
[0]);
17953 digest
[1] = byte_swap_32 (digest
[1]);
17954 digest
[2] = byte_swap_32 (digest
[2]);
17955 digest
[3] = byte_swap_32 (digest
[3]);
17957 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17959 uint salt_len
= input_len
- 32 - 1;
17961 char *salt_buf
= input_buf
+ 32 + 1;
17963 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17965 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17967 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17969 salt
->salt_len
= salt_len
;
17971 return (PARSER_OK
);
17974 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17976 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17978 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17980 u32
*digest
= (u32
*) hash_buf
->digest
;
17982 salt_t
*salt
= hash_buf
->salt
;
17984 char *user_pos
= input_buf
+ 10;
17986 char *salt_pos
= strchr (user_pos
, '*');
17988 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17992 char *hash_pos
= strchr (salt_pos
, '*');
17996 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17998 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18000 uint user_len
= salt_pos
- user_pos
- 1;
18002 uint salt_len
= hash_pos
- salt_pos
- 1;
18004 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18010 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18011 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18012 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18013 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18015 digest
[0] = byte_swap_32 (digest
[0]);
18016 digest
[1] = byte_swap_32 (digest
[1]);
18017 digest
[2] = byte_swap_32 (digest
[2]);
18018 digest
[3] = byte_swap_32 (digest
[3]);
18020 digest
[0] -= MD5M_A
;
18021 digest
[1] -= MD5M_B
;
18022 digest
[2] -= MD5M_C
;
18023 digest
[3] -= MD5M_D
;
18029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18031 // first 4 bytes are the "challenge"
18033 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18034 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18035 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18036 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18038 // append the user name
18040 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18042 salt
->salt_len
= 4 + user_len
;
18044 return (PARSER_OK
);
18047 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18049 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18051 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18053 u32
*digest
= (u32
*) hash_buf
->digest
;
18055 salt_t
*salt
= hash_buf
->salt
;
18057 char *salt_pos
= input_buf
+ 9;
18059 char *hash_pos
= strchr (salt_pos
, '*');
18061 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18065 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18067 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18069 uint salt_len
= hash_pos
- salt_pos
- 1;
18071 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18077 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18078 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18079 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18080 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18081 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18089 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18091 salt
->salt_len
= salt_len
;
18093 return (PARSER_OK
);
18096 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18098 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18100 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18102 u32
*digest
= (u32
*) hash_buf
->digest
;
18104 salt_t
*salt
= hash_buf
->salt
;
18106 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18112 char *cry_master_len_pos
= input_buf
+ 9;
18114 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18116 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18118 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18120 cry_master_buf_pos
++;
18122 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18124 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18126 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18128 cry_salt_len_pos
++;
18130 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18132 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18134 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18136 cry_salt_buf_pos
++;
18138 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18140 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18142 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18146 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18148 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18150 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18154 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18156 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18158 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18162 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18164 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18166 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18168 public_key_len_pos
++;
18170 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18172 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18174 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18176 public_key_buf_pos
++;
18178 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;
18180 const uint cry_master_len
= atoi (cry_master_len_pos
);
18181 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18182 const uint ckey_len
= atoi (ckey_len_pos
);
18183 const uint public_key_len
= atoi (public_key_len_pos
);
18185 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18186 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18187 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18188 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18190 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18192 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18194 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18197 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18199 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18201 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18204 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18206 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18208 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18211 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18212 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18213 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18216 * store digest (should be unique enought, hopefully)
18219 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18220 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18221 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18222 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18228 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18230 const uint cry_rounds
= atoi (cry_rounds_pos
);
18232 salt
->salt_iter
= cry_rounds
- 1;
18234 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18236 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18238 salt
->salt_len
= salt_len
;
18240 return (PARSER_OK
);
18243 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18245 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18247 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18249 u32
*digest
= (u32
*) hash_buf
->digest
;
18251 salt_t
*salt
= hash_buf
->salt
;
18253 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18255 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18257 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18259 memcpy (temp_input_buf
, input_buf
, input_len
);
18263 char *URI_server_pos
= temp_input_buf
+ 6;
18265 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18267 if (URI_client_pos
== NULL
)
18269 myfree (temp_input_buf
);
18271 return (PARSER_SEPARATOR_UNMATCHED
);
18274 URI_client_pos
[0] = 0;
18277 uint URI_server_len
= strlen (URI_server_pos
);
18279 if (URI_server_len
> 512)
18281 myfree (temp_input_buf
);
18283 return (PARSER_SALT_LENGTH
);
18288 char *user_pos
= strchr (URI_client_pos
, '*');
18290 if (user_pos
== NULL
)
18292 myfree (temp_input_buf
);
18294 return (PARSER_SEPARATOR_UNMATCHED
);
18300 uint URI_client_len
= strlen (URI_client_pos
);
18302 if (URI_client_len
> 512)
18304 myfree (temp_input_buf
);
18306 return (PARSER_SALT_LENGTH
);
18311 char *realm_pos
= strchr (user_pos
, '*');
18313 if (realm_pos
== NULL
)
18315 myfree (temp_input_buf
);
18317 return (PARSER_SEPARATOR_UNMATCHED
);
18323 uint user_len
= strlen (user_pos
);
18325 if (user_len
> 116)
18327 myfree (temp_input_buf
);
18329 return (PARSER_SALT_LENGTH
);
18334 char *method_pos
= strchr (realm_pos
, '*');
18336 if (method_pos
== NULL
)
18338 myfree (temp_input_buf
);
18340 return (PARSER_SEPARATOR_UNMATCHED
);
18346 uint realm_len
= strlen (realm_pos
);
18348 if (realm_len
> 116)
18350 myfree (temp_input_buf
);
18352 return (PARSER_SALT_LENGTH
);
18357 char *URI_prefix_pos
= strchr (method_pos
, '*');
18359 if (URI_prefix_pos
== NULL
)
18361 myfree (temp_input_buf
);
18363 return (PARSER_SEPARATOR_UNMATCHED
);
18366 URI_prefix_pos
[0] = 0;
18369 uint method_len
= strlen (method_pos
);
18371 if (method_len
> 246)
18373 myfree (temp_input_buf
);
18375 return (PARSER_SALT_LENGTH
);
18380 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18382 if (URI_resource_pos
== NULL
)
18384 myfree (temp_input_buf
);
18386 return (PARSER_SEPARATOR_UNMATCHED
);
18389 URI_resource_pos
[0] = 0;
18390 URI_resource_pos
++;
18392 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18394 if (URI_prefix_len
> 245)
18396 myfree (temp_input_buf
);
18398 return (PARSER_SALT_LENGTH
);
18403 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18405 if (URI_suffix_pos
== NULL
)
18407 myfree (temp_input_buf
);
18409 return (PARSER_SEPARATOR_UNMATCHED
);
18412 URI_suffix_pos
[0] = 0;
18415 uint URI_resource_len
= strlen (URI_resource_pos
);
18417 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18419 myfree (temp_input_buf
);
18421 return (PARSER_SALT_LENGTH
);
18426 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18428 if (nonce_pos
== NULL
)
18430 myfree (temp_input_buf
);
18432 return (PARSER_SEPARATOR_UNMATCHED
);
18438 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18440 if (URI_suffix_len
> 245)
18442 myfree (temp_input_buf
);
18444 return (PARSER_SALT_LENGTH
);
18449 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18451 if (nonce_client_pos
== NULL
)
18453 myfree (temp_input_buf
);
18455 return (PARSER_SEPARATOR_UNMATCHED
);
18458 nonce_client_pos
[0] = 0;
18459 nonce_client_pos
++;
18461 uint nonce_len
= strlen (nonce_pos
);
18463 if (nonce_len
< 1 || nonce_len
> 50)
18465 myfree (temp_input_buf
);
18467 return (PARSER_SALT_LENGTH
);
18472 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18474 if (nonce_count_pos
== NULL
)
18476 myfree (temp_input_buf
);
18478 return (PARSER_SEPARATOR_UNMATCHED
);
18481 nonce_count_pos
[0] = 0;
18484 uint nonce_client_len
= strlen (nonce_client_pos
);
18486 if (nonce_client_len
> 50)
18488 myfree (temp_input_buf
);
18490 return (PARSER_SALT_LENGTH
);
18495 char *qop_pos
= strchr (nonce_count_pos
, '*');
18497 if (qop_pos
== NULL
)
18499 myfree (temp_input_buf
);
18501 return (PARSER_SEPARATOR_UNMATCHED
);
18507 uint nonce_count_len
= strlen (nonce_count_pos
);
18509 if (nonce_count_len
> 50)
18511 myfree (temp_input_buf
);
18513 return (PARSER_SALT_LENGTH
);
18518 char *directive_pos
= strchr (qop_pos
, '*');
18520 if (directive_pos
== NULL
)
18522 myfree (temp_input_buf
);
18524 return (PARSER_SEPARATOR_UNMATCHED
);
18527 directive_pos
[0] = 0;
18530 uint qop_len
= strlen (qop_pos
);
18534 myfree (temp_input_buf
);
18536 return (PARSER_SALT_LENGTH
);
18541 char *digest_pos
= strchr (directive_pos
, '*');
18543 if (digest_pos
== NULL
)
18545 myfree (temp_input_buf
);
18547 return (PARSER_SEPARATOR_UNMATCHED
);
18553 uint directive_len
= strlen (directive_pos
);
18555 if (directive_len
!= 3)
18557 myfree (temp_input_buf
);
18559 return (PARSER_SALT_LENGTH
);
18562 if (memcmp (directive_pos
, "MD5", 3))
18564 log_info ("ERROR: only the MD5 directive is currently supported\n");
18566 myfree (temp_input_buf
);
18568 return (PARSER_SIP_AUTH_DIRECTIVE
);
18572 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18577 uint md5_max_len
= 4 * 64;
18579 uint md5_remaining_len
= md5_max_len
;
18581 uint tmp_md5_buf
[64] = { 0 };
18583 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18585 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18587 md5_len
+= method_len
+ 1;
18588 tmp_md5_ptr
+= method_len
+ 1;
18590 if (URI_prefix_len
> 0)
18592 md5_remaining_len
= md5_max_len
- md5_len
;
18594 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18596 md5_len
+= URI_prefix_len
+ 1;
18597 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18600 md5_remaining_len
= md5_max_len
- md5_len
;
18602 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18604 md5_len
+= URI_resource_len
;
18605 tmp_md5_ptr
+= URI_resource_len
;
18607 if (URI_suffix_len
> 0)
18609 md5_remaining_len
= md5_max_len
- md5_len
;
18611 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18613 md5_len
+= 1 + URI_suffix_len
;
18616 uint tmp_digest
[4] = { 0 };
18618 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18620 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18621 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18622 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18623 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18629 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18631 uint esalt_len
= 0;
18633 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18635 // there are 2 possibilities for the esalt:
18637 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18639 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18641 if (esalt_len
> max_esalt_len
)
18643 myfree (temp_input_buf
);
18645 return (PARSER_SALT_LENGTH
);
18648 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18660 esalt_len
= 1 + nonce_len
+ 1 + 32;
18662 if (esalt_len
> max_esalt_len
)
18664 myfree (temp_input_buf
);
18666 return (PARSER_SALT_LENGTH
);
18669 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18677 // add 0x80 to esalt
18679 esalt_buf_ptr
[esalt_len
] = 0x80;
18681 sip
->esalt_len
= esalt_len
;
18687 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18689 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18691 uint max_salt_len
= 119;
18693 if (salt_len
> max_salt_len
)
18695 myfree (temp_input_buf
);
18697 return (PARSER_SALT_LENGTH
);
18700 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18702 sip
->salt_len
= salt_len
;
18705 * fake salt (for sorting)
18708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18712 uint fake_salt_len
= salt_len
;
18714 if (fake_salt_len
> max_salt_len
)
18716 fake_salt_len
= max_salt_len
;
18719 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18721 salt
->salt_len
= fake_salt_len
;
18727 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18728 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18729 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18730 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18732 digest
[0] = byte_swap_32 (digest
[0]);
18733 digest
[1] = byte_swap_32 (digest
[1]);
18734 digest
[2] = byte_swap_32 (digest
[2]);
18735 digest
[3] = byte_swap_32 (digest
[3]);
18737 myfree (temp_input_buf
);
18739 return (PARSER_OK
);
18742 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18744 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18746 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18748 u32
*digest
= (u32
*) hash_buf
->digest
;
18750 salt_t
*salt
= hash_buf
->salt
;
18754 char *digest_pos
= input_buf
;
18756 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18763 char *salt_buf
= input_buf
+ 8 + 1;
18767 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18769 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18771 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18773 salt
->salt_len
= salt_len
;
18775 return (PARSER_OK
);
18778 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18780 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18782 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18784 u32
*digest
= (u32
*) hash_buf
->digest
;
18786 salt_t
*salt
= hash_buf
->salt
;
18788 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18794 char *p_buf_pos
= input_buf
+ 4;
18796 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18798 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18800 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18802 NumCyclesPower_pos
++;
18804 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18806 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18808 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18812 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18814 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18816 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18820 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18822 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18824 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18828 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18830 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18832 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18836 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18838 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18840 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18844 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18846 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18848 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18852 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18854 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18856 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18860 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18862 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18864 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18868 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;
18870 const uint iter
= atoi (NumCyclesPower_pos
);
18871 const uint crc
= atoi (crc_buf_pos
);
18872 const uint p_buf
= atoi (p_buf_pos
);
18873 const uint salt_len
= atoi (salt_len_pos
);
18874 const uint iv_len
= atoi (iv_len_pos
);
18875 const uint unpack_size
= atoi (unpack_size_pos
);
18876 const uint data_len
= atoi (data_len_pos
);
18882 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18883 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18885 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18887 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18889 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18895 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18896 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18897 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18898 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18900 seven_zip
->iv_len
= iv_len
;
18902 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18904 seven_zip
->salt_len
= 0;
18906 seven_zip
->crc
= crc
;
18908 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18910 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18912 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18915 seven_zip
->data_len
= data_len
;
18917 seven_zip
->unpack_size
= unpack_size
;
18921 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18922 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18923 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18924 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18926 salt
->salt_len
= 16;
18928 salt
->salt_sign
[0] = iter
;
18930 salt
->salt_iter
= 1 << iter
;
18941 return (PARSER_OK
);
18944 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18946 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18948 u32
*digest
= (u32
*) hash_buf
->digest
;
18950 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18951 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18952 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18953 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18954 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18955 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18956 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18957 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18959 digest
[0] = byte_swap_32 (digest
[0]);
18960 digest
[1] = byte_swap_32 (digest
[1]);
18961 digest
[2] = byte_swap_32 (digest
[2]);
18962 digest
[3] = byte_swap_32 (digest
[3]);
18963 digest
[4] = byte_swap_32 (digest
[4]);
18964 digest
[5] = byte_swap_32 (digest
[5]);
18965 digest
[6] = byte_swap_32 (digest
[6]);
18966 digest
[7] = byte_swap_32 (digest
[7]);
18968 return (PARSER_OK
);
18971 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18973 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18975 u32
*digest
= (u32
*) hash_buf
->digest
;
18977 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18978 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18979 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18980 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18981 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18982 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18983 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18984 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18985 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18986 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18987 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18988 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18989 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18990 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18991 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18992 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18994 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18995 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18996 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18997 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18998 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18999 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19000 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19001 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19002 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19003 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19004 digest
[10] = byte_swap_32 (digest
[10]);
19005 digest
[11] = byte_swap_32 (digest
[11]);
19006 digest
[12] = byte_swap_32 (digest
[12]);
19007 digest
[13] = byte_swap_32 (digest
[13]);
19008 digest
[14] = byte_swap_32 (digest
[14]);
19009 digest
[15] = byte_swap_32 (digest
[15]);
19011 return (PARSER_OK
);
19014 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19016 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19018 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19020 u32
*digest
= (u32
*) hash_buf
->digest
;
19022 salt_t
*salt
= hash_buf
->salt
;
19024 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19032 char *iter_pos
= input_buf
+ 4;
19034 u32 iter
= atoi (iter_pos
);
19036 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19037 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19039 // first is *raw* salt
19041 char *salt_pos
= strchr (iter_pos
, ':');
19043 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19047 char *hash_pos
= strchr (salt_pos
, ':');
19049 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19051 u32 salt_len
= hash_pos
- salt_pos
;
19053 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19057 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19059 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19063 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19065 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19067 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19069 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19070 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19072 salt
->salt_len
= salt_len
;
19073 salt
->salt_iter
= iter
- 1;
19077 u8 tmp_buf
[100] = { 0 };
19079 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19081 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19083 memcpy (digest
, tmp_buf
, 16);
19085 // add some stuff to normal salt to make sorted happy
19087 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19088 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19089 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19090 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19091 salt
->salt_buf
[4] = salt
->salt_iter
;
19093 return (PARSER_OK
);
19096 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19098 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19100 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19102 u32
*digest
= (u32
*) hash_buf
->digest
;
19104 salt_t
*salt
= hash_buf
->salt
;
19106 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19114 char *iter_pos
= input_buf
+ 5;
19116 u32 iter
= atoi (iter_pos
);
19118 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19119 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19121 // first is *raw* salt
19123 char *salt_pos
= strchr (iter_pos
, ':');
19125 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19129 char *hash_pos
= strchr (salt_pos
, ':');
19131 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19133 u32 salt_len
= hash_pos
- salt_pos
;
19135 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19139 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19141 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19145 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19151 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19152 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19154 salt
->salt_len
= salt_len
;
19155 salt
->salt_iter
= iter
- 1;
19159 u8 tmp_buf
[100] = { 0 };
19161 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19163 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19165 memcpy (digest
, tmp_buf
, 16);
19167 digest
[0] = byte_swap_32 (digest
[0]);
19168 digest
[1] = byte_swap_32 (digest
[1]);
19169 digest
[2] = byte_swap_32 (digest
[2]);
19170 digest
[3] = byte_swap_32 (digest
[3]);
19172 // add some stuff to normal salt to make sorted happy
19174 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19175 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19176 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19177 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19178 salt
->salt_buf
[4] = salt
->salt_iter
;
19180 return (PARSER_OK
);
19183 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19185 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19187 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19189 u64
*digest
= (u64
*) hash_buf
->digest
;
19191 salt_t
*salt
= hash_buf
->salt
;
19193 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19201 char *iter_pos
= input_buf
+ 7;
19203 u32 iter
= atoi (iter_pos
);
19205 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19206 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19208 // first is *raw* salt
19210 char *salt_pos
= strchr (iter_pos
, ':');
19212 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19216 char *hash_pos
= strchr (salt_pos
, ':');
19218 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19220 u32 salt_len
= hash_pos
- salt_pos
;
19222 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19226 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19228 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19232 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19234 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19236 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19238 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19239 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19241 salt
->salt_len
= salt_len
;
19242 salt
->salt_iter
= iter
- 1;
19246 u8 tmp_buf
[100] = { 0 };
19248 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19250 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19252 memcpy (digest
, tmp_buf
, 64);
19254 digest
[0] = byte_swap_64 (digest
[0]);
19255 digest
[1] = byte_swap_64 (digest
[1]);
19256 digest
[2] = byte_swap_64 (digest
[2]);
19257 digest
[3] = byte_swap_64 (digest
[3]);
19258 digest
[4] = byte_swap_64 (digest
[4]);
19259 digest
[5] = byte_swap_64 (digest
[5]);
19260 digest
[6] = byte_swap_64 (digest
[6]);
19261 digest
[7] = byte_swap_64 (digest
[7]);
19263 // add some stuff to normal salt to make sorted happy
19265 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19266 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19267 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19268 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19269 salt
->salt_buf
[4] = salt
->salt_iter
;
19271 return (PARSER_OK
);
19274 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19276 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19278 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19280 uint
*digest
= (uint
*) hash_buf
->digest
;
19282 salt_t
*salt
= hash_buf
->salt
;
19288 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19290 char *hash_pos
= strchr (salt_pos
, '$');
19292 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19294 u32 salt_len
= hash_pos
- salt_pos
;
19296 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19300 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19302 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19306 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19307 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19325 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19326 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19328 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19329 salt
->salt_len
= 8;
19331 return (PARSER_OK
);
19334 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19336 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19338 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19340 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19342 if (c19
& 3) return (PARSER_HASH_VALUE
);
19344 salt_t
*salt
= hash_buf
->salt
;
19346 u32
*digest
= (u32
*) hash_buf
->digest
;
19350 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19351 | itoa64_to_int (input_buf
[2]) << 6
19352 | itoa64_to_int (input_buf
[3]) << 12
19353 | itoa64_to_int (input_buf
[4]) << 18;
19357 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19358 | itoa64_to_int (input_buf
[6]) << 6
19359 | itoa64_to_int (input_buf
[7]) << 12
19360 | itoa64_to_int (input_buf
[8]) << 18;
19362 salt
->salt_len
= 4;
19364 u8 tmp_buf
[100] = { 0 };
19366 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19368 memcpy (digest
, tmp_buf
, 8);
19372 IP (digest
[0], digest
[1], tt
);
19374 digest
[0] = rotr32 (digest
[0], 31);
19375 digest
[1] = rotr32 (digest
[1], 31);
19379 return (PARSER_OK
);
19382 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19384 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19386 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19388 u32
*digest
= (u32
*) hash_buf
->digest
;
19390 salt_t
*salt
= hash_buf
->salt
;
19396 char *type_pos
= input_buf
+ 6 + 1;
19398 char *salt_pos
= strchr (type_pos
, '*');
19400 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19402 u32 type_len
= salt_pos
- type_pos
;
19404 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19408 char *crypted_pos
= strchr (salt_pos
, '*');
19410 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19412 u32 salt_len
= crypted_pos
- salt_pos
;
19414 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19418 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19420 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19426 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19427 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19429 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19430 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19432 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19433 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19434 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19435 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19437 salt
->salt_len
= 24;
19438 salt
->salt_iter
= ROUNDS_RAR3
;
19440 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19441 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19443 digest
[0] = 0xc43d7b00;
19444 digest
[1] = 0x40070000;
19448 return (PARSER_OK
);
19451 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19453 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19455 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19457 u32
*digest
= (u32
*) hash_buf
->digest
;
19459 salt_t
*salt
= hash_buf
->salt
;
19461 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19467 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19469 char *param1_pos
= strchr (param0_pos
, '$');
19471 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19473 u32 param0_len
= param1_pos
- param0_pos
;
19477 char *param2_pos
= strchr (param1_pos
, '$');
19479 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19481 u32 param1_len
= param2_pos
- param1_pos
;
19485 char *param3_pos
= strchr (param2_pos
, '$');
19487 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19489 u32 param2_len
= param3_pos
- param2_pos
;
19493 char *param4_pos
= strchr (param3_pos
, '$');
19495 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19497 u32 param3_len
= param4_pos
- param3_pos
;
19501 char *param5_pos
= strchr (param4_pos
, '$');
19503 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19505 u32 param4_len
= param5_pos
- param4_pos
;
19509 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19511 char *salt_buf
= param1_pos
;
19512 char *iv
= param3_pos
;
19513 char *pswcheck
= param5_pos
;
19515 const uint salt_len
= atoi (param0_pos
);
19516 const uint iterations
= atoi (param2_pos
);
19517 const uint pswcheck_len
= atoi (param4_pos
);
19523 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19524 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19525 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19527 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19528 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19529 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19535 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19536 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19537 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19538 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19540 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19541 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19542 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19543 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19545 salt
->salt_len
= 16;
19547 salt
->salt_sign
[0] = iterations
;
19549 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19555 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19556 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19560 return (PARSER_OK
);
19563 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19565 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19567 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19569 u32
*digest
= (u32
*) hash_buf
->digest
;
19571 salt_t
*salt
= hash_buf
->salt
;
19573 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19580 char *account_pos
= input_buf
+ 11 + 1;
19586 if (account_pos
[0] == '*')
19590 data_pos
= strchr (account_pos
, '*');
19595 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19597 uint account_len
= data_pos
- account_pos
+ 1;
19599 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19604 data_len
= input_len
- 11 - 1 - account_len
- 2;
19606 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19610 /* assume $krb5tgs$23$checksum$edata2 */
19611 data_pos
= account_pos
;
19613 memcpy (krb5tgs
->account_info
, "**", 3);
19615 data_len
= input_len
- 11 - 1 - 1;
19618 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19620 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19622 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19624 const char p0
= data_pos
[i
+ 0];
19625 const char p1
= data_pos
[i
+ 1];
19627 *checksum_ptr
++ = hex_convert (p1
) << 0
19628 | hex_convert (p0
) << 4;
19631 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19633 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19636 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19638 const char p0
= data_pos
[i
+ 0];
19639 const char p1
= data_pos
[i
+ 1];
19640 *edata_ptr
++ = hex_convert (p1
) << 0
19641 | hex_convert (p0
) << 4;
19644 /* this is needed for hmac_md5 */
19645 *edata_ptr
++ = 0x80;
19647 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19648 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19649 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19650 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19652 salt
->salt_len
= 32;
19654 digest
[0] = krb5tgs
->checksum
[0];
19655 digest
[1] = krb5tgs
->checksum
[1];
19656 digest
[2] = krb5tgs
->checksum
[2];
19657 digest
[3] = krb5tgs
->checksum
[3];
19659 return (PARSER_OK
);
19662 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19664 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19666 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19668 u32
*digest
= (u32
*) hash_buf
->digest
;
19670 salt_t
*salt
= hash_buf
->salt
;
19677 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19681 char *wrapped_key_pos
;
19685 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19687 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19689 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19691 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19696 data_pos
= salt_pos
;
19698 wrapped_key_pos
= strchr (salt_pos
, '*');
19700 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19702 uint salt_len
= wrapped_key_pos
- salt_pos
;
19704 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19709 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19711 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19713 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19714 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19715 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19716 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19720 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19721 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19722 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19723 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19724 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19725 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19727 salt
->salt_len
= 40;
19729 digest
[0] = salt
->salt_buf
[0];
19730 digest
[1] = salt
->salt_buf
[1];
19731 digest
[2] = salt
->salt_buf
[2];
19732 digest
[3] = salt
->salt_buf
[3];
19734 return (PARSER_OK
);
19737 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19739 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19741 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19743 u32
*digest
= (u32
*) hash_buf
->digest
;
19745 salt_t
*salt
= hash_buf
->salt
;
19747 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19757 char *algorithm_pos
;
19759 char *final_random_seed_pos
;
19760 u32 final_random_seed_len
;
19762 char *transf_random_seed_pos
;
19763 u32 transf_random_seed_len
;
19768 /* default is no keyfile provided */
19769 char *keyfile_len_pos
;
19770 u32 keyfile_len
= 0;
19771 u32 is_keyfile_present
= 0;
19772 char *keyfile_inline_pos
;
19775 /* specific to version 1 */
19776 char *contents_len_pos
;
19778 char *contents_pos
;
19780 /* specific to version 2 */
19781 char *expected_bytes_pos
;
19782 u32 expected_bytes_len
;
19784 char *contents_hash_pos
;
19785 u32 contents_hash_len
;
19787 version_pos
= input_buf
+ 8 + 1 + 1;
19789 keepass
->version
= atoi (version_pos
);
19791 rounds_pos
= strchr (version_pos
, '*');
19793 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19797 salt
->salt_iter
= (atoi (rounds_pos
));
19799 algorithm_pos
= strchr (rounds_pos
, '*');
19801 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19805 keepass
->algorithm
= atoi (algorithm_pos
);
19807 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19809 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19811 final_random_seed_pos
++;
19813 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19814 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19815 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19816 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19818 if (keepass
->version
== 2)
19820 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19821 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19822 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19823 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19826 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19828 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19830 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19832 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19833 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19835 transf_random_seed_pos
++;
19837 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19838 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19839 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19840 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19841 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19842 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19843 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19844 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19846 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19848 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19850 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19852 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19856 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19857 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19858 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19859 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19861 if (keepass
->version
== 1)
19863 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19865 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19867 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19869 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19871 contents_hash_pos
++;
19873 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19874 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19875 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19876 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19877 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19878 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19879 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19880 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19882 /* get length of contents following */
19883 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19885 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19887 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19889 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19893 u32 inline_flag
= atoi (inline_flag_pos
);
19895 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19897 contents_len_pos
= strchr (inline_flag_pos
, '*');
19899 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19901 contents_len_pos
++;
19903 contents_len
= atoi (contents_len_pos
);
19905 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19907 contents_pos
= strchr (contents_len_pos
, '*');
19909 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19915 keepass
->contents_len
= contents_len
;
19917 contents_len
= contents_len
/ 4;
19919 keyfile_inline_pos
= strchr (contents_pos
, '*');
19921 u32 real_contents_len
;
19923 if (keyfile_inline_pos
== NULL
)
19924 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19927 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19928 keyfile_inline_pos
++;
19929 is_keyfile_present
= 1;
19932 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19934 for (i
= 0; i
< contents_len
; i
++)
19935 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19937 else if (keepass
->version
== 2)
19939 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19941 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19943 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19945 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19947 expected_bytes_pos
++;
19949 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19950 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19951 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19952 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19953 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19954 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19955 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19956 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19958 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19960 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19962 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19964 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19966 contents_hash_pos
++;
19968 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19969 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19970 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19971 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19972 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19973 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19974 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19975 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19977 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19979 if (keyfile_inline_pos
== NULL
)
19980 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19983 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19984 keyfile_inline_pos
++;
19985 is_keyfile_present
= 1;
19987 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19990 if (is_keyfile_present
!= 0)
19992 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19996 keyfile_len
= atoi (keyfile_len_pos
);
19998 keepass
->keyfile_len
= keyfile_len
;
20000 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20002 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20004 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20008 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20010 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20012 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20013 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20014 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20015 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20016 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20017 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20018 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20019 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20022 digest
[0] = keepass
->enc_iv
[0];
20023 digest
[1] = keepass
->enc_iv
[1];
20024 digest
[2] = keepass
->enc_iv
[2];
20025 digest
[3] = keepass
->enc_iv
[3];
20027 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20028 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20029 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20030 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20031 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20032 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20033 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20034 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20036 return (PARSER_OK
);
20039 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20041 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20043 u32
*digest
= (u32
*) hash_buf
->digest
;
20045 salt_t
*salt
= hash_buf
->salt
;
20047 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20048 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20049 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20050 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20051 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20052 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20053 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20054 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20056 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20058 uint salt_len
= input_len
- 64 - 1;
20060 char *salt_buf
= input_buf
+ 64 + 1;
20062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20064 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20066 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20068 salt
->salt_len
= salt_len
;
20071 * we can precompute the first sha256 transform
20074 uint w
[16] = { 0 };
20076 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20077 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20078 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20079 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20080 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20081 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20082 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20083 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20084 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20085 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20086 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20087 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20088 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20089 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20090 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20091 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20093 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20095 sha256_64 (w
, pc256
);
20097 salt
->salt_buf_pc
[0] = pc256
[0];
20098 salt
->salt_buf_pc
[1] = pc256
[1];
20099 salt
->salt_buf_pc
[2] = pc256
[2];
20100 salt
->salt_buf_pc
[3] = pc256
[3];
20101 salt
->salt_buf_pc
[4] = pc256
[4];
20102 salt
->salt_buf_pc
[5] = pc256
[5];
20103 salt
->salt_buf_pc
[6] = pc256
[6];
20104 salt
->salt_buf_pc
[7] = pc256
[7];
20106 digest
[0] -= pc256
[0];
20107 digest
[1] -= pc256
[1];
20108 digest
[2] -= pc256
[2];
20109 digest
[3] -= pc256
[3];
20110 digest
[4] -= pc256
[4];
20111 digest
[5] -= pc256
[5];
20112 digest
[6] -= pc256
[6];
20113 digest
[7] -= pc256
[7];
20115 return (PARSER_OK
);
20118 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20120 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20122 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20124 u32
*digest
= (u32
*) hash_buf
->digest
;
20126 salt_t
*salt
= hash_buf
->salt
;
20132 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20134 char *data_buf_pos
= strchr (data_len_pos
, '$');
20136 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20138 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20140 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20141 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20145 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20147 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20149 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20151 u32 data_len
= atoi (data_len_pos
);
20153 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20159 char *salt_pos
= data_buf_pos
;
20161 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20162 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20163 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20164 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20166 // this is actually the CT, which is also the hash later (if matched)
20168 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20169 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20170 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20171 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20173 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20175 salt
->salt_iter
= 10 - 1;
20181 digest
[0] = salt
->salt_buf
[4];
20182 digest
[1] = salt
->salt_buf
[5];
20183 digest
[2] = salt
->salt_buf
[6];
20184 digest
[3] = salt
->salt_buf
[7];
20186 return (PARSER_OK
);
20189 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20191 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20193 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20195 u32
*digest
= (u32
*) hash_buf
->digest
;
20197 salt_t
*salt
= hash_buf
->salt
;
20203 char *salt_pos
= input_buf
+ 11 + 1;
20205 char *iter_pos
= strchr (salt_pos
, ',');
20207 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20209 u32 salt_len
= iter_pos
- salt_pos
;
20211 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20215 char *hash_pos
= strchr (iter_pos
, ',');
20217 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20219 u32 iter_len
= hash_pos
- iter_pos
;
20221 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20225 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20227 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20233 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20234 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20235 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20236 salt
->salt_buf
[3] = 0x00018000;
20238 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20239 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20240 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20241 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20243 salt
->salt_len
= salt_len
/ 2;
20245 salt
->salt_iter
= atoi (iter_pos
) - 1;
20251 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20252 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20253 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20254 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20255 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20256 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20257 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20258 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20260 return (PARSER_OK
);
20263 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20265 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20267 u32
*digest
= (u32
*) hash_buf
->digest
;
20269 salt_t
*salt
= hash_buf
->salt
;
20275 char *hash_pos
= input_buf
+ 64;
20276 char *salt1_pos
= input_buf
+ 128;
20277 char *salt2_pos
= input_buf
;
20283 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20284 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20285 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20286 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20288 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20289 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20290 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20291 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20293 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20294 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20295 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20296 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20298 salt
->salt_len
= 48;
20300 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20306 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20307 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20308 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20309 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20310 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20311 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20312 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20313 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20315 return (PARSER_OK
);
20318 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20320 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20322 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20323 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20325 u32
*digest
= (u32
*) hash_buf
->digest
;
20327 salt_t
*salt
= hash_buf
->salt
;
20329 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20335 char *param0_pos
= input_buf
+ 6 + 1;
20337 char *param1_pos
= strchr (param0_pos
, '*');
20339 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20341 u32 param0_len
= param1_pos
- param0_pos
;
20345 char *param2_pos
= strchr (param1_pos
, '*');
20347 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20349 u32 param1_len
= param2_pos
- param1_pos
;
20353 char *param3_pos
= strchr (param2_pos
, '*');
20355 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20357 u32 param2_len
= param3_pos
- param2_pos
;
20361 char *param4_pos
= strchr (param3_pos
, '*');
20363 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20365 u32 param3_len
= param4_pos
- param3_pos
;
20369 char *param5_pos
= strchr (param4_pos
, '*');
20371 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20373 u32 param4_len
= param5_pos
- param4_pos
;
20377 char *param6_pos
= strchr (param5_pos
, '*');
20379 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20381 u32 param5_len
= param6_pos
- param5_pos
;
20385 char *param7_pos
= strchr (param6_pos
, '*');
20387 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20389 u32 param6_len
= param7_pos
- param6_pos
;
20393 char *param8_pos
= strchr (param7_pos
, '*');
20395 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20397 u32 param7_len
= param8_pos
- param7_pos
;
20401 const uint type
= atoi (param0_pos
);
20402 const uint mode
= atoi (param1_pos
);
20403 const uint magic
= atoi (param2_pos
);
20405 char *salt_buf
= param3_pos
;
20407 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20409 const uint compress_length
= atoi (param5_pos
);
20411 char *data_buf
= param6_pos
;
20412 char *auth
= param7_pos
;
20418 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20420 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20422 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20424 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20426 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20428 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20430 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20432 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20434 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20436 if (type
!= 0) return (PARSER_SALT_VALUE
);
20438 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20440 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20442 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20450 zip2
->magic
= magic
;
20454 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20455 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20456 zip2
->salt_buf
[2] = 0;
20457 zip2
->salt_buf
[3] = 0;
20459 zip2
->salt_len
= 8;
20461 else if (mode
== 2)
20463 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20464 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20465 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20466 zip2
->salt_buf
[3] = 0;
20468 zip2
->salt_len
= 12;
20470 else if (mode
== 3)
20472 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20473 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20474 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20475 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20477 zip2
->salt_len
= 16;
20480 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20481 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20482 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20483 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20485 zip2
->verify_bytes
= verify_bytes
;
20487 zip2
->compress_length
= compress_length
;
20489 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20491 for (uint i
= 0; i
< param6_len
; i
+= 2)
20493 const char p0
= data_buf
[i
+ 0];
20494 const char p1
= data_buf
[i
+ 1];
20496 *data_buf_ptr
++ = hex_convert (p1
) << 0
20497 | hex_convert (p0
) << 4;
20502 *data_buf_ptr
= 0x80;
20504 char *auth_ptr
= (char *) zip2
->auth_buf
;
20506 for (uint i
= 0; i
< param7_len
; i
+= 2)
20508 const char p0
= auth
[i
+ 0];
20509 const char p1
= auth
[i
+ 1];
20511 *auth_ptr
++ = hex_convert (p1
) << 0
20512 | hex_convert (p0
) << 4;
20521 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20522 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20523 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20524 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20525 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20526 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20527 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20528 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20530 salt
->salt_len
= 32;
20532 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20535 * digest buf (fake)
20538 digest
[0] = zip2
->auth_buf
[0];
20539 digest
[1] = zip2
->auth_buf
[1];
20540 digest
[2] = zip2
->auth_buf
[2];
20541 digest
[3] = zip2
->auth_buf
[3];
20543 return (PARSER_OK
);
20546 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20548 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20550 u32
*digest
= (u32
*) hash_buf
->digest
;
20552 salt_t
*salt
= hash_buf
->salt
;
20554 win8phone_t
*esalt
= hash_buf
->esalt
;
20556 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20557 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20558 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20559 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20560 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20561 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20562 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20563 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20565 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20567 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20569 u32
*salt_buf
= esalt
->salt_buf
;
20571 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20573 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20576 salt
->salt_buf
[0] = salt_buf
[0];
20577 salt
->salt_buf
[1] = salt_buf
[1];
20578 salt
->salt_buf
[2] = salt_buf
[2];
20579 salt
->salt_buf
[3] = salt_buf
[3];
20580 salt
->salt_buf
[4] = salt_buf
[4];
20581 salt
->salt_buf
[5] = salt_buf
[5];
20582 salt
->salt_buf
[6] = salt_buf
[6];
20583 salt
->salt_buf
[7] = salt_buf
[7];
20585 salt
->salt_len
= 64;
20587 return (PARSER_OK
);
20591 * parallel running threads
20596 BOOL WINAPI
sigHandler_default (DWORD sig
)
20600 case CTRL_CLOSE_EVENT
:
20603 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20604 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20605 * function otherwise it is too late (e.g. after returning from this function)
20610 SetConsoleCtrlHandler (NULL
, TRUE
);
20617 case CTRL_LOGOFF_EVENT
:
20618 case CTRL_SHUTDOWN_EVENT
:
20622 SetConsoleCtrlHandler (NULL
, TRUE
);
20630 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20634 case CTRL_CLOSE_EVENT
:
20638 SetConsoleCtrlHandler (NULL
, TRUE
);
20645 case CTRL_LOGOFF_EVENT
:
20646 case CTRL_SHUTDOWN_EVENT
:
20650 SetConsoleCtrlHandler (NULL
, TRUE
);
20658 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20660 if (callback
== NULL
)
20662 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20666 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20672 void sigHandler_default (int sig
)
20676 signal (sig
, NULL
);
20679 void sigHandler_benchmark (int sig
)
20683 signal (sig
, NULL
);
20686 void hc_signal (void (callback
) (int))
20688 if (callback
== NULL
) callback
= SIG_DFL
;
20690 signal (SIGINT
, callback
);
20691 signal (SIGTERM
, callback
);
20692 signal (SIGABRT
, callback
);
20697 void status_display ();
20699 void *thread_keypress (void *p
)
20701 int benchmark
= *((int *) p
);
20703 uint quiet
= data
.quiet
;
20707 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20709 int ch
= tty_getchar();
20711 if (ch
== -1) break;
20713 if (ch
== 0) continue;
20715 //https://github.com/hashcat/hashcat/issues/302
20720 hc_thread_mutex_lock (mux_display
);
20736 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20737 if (quiet
== 0) fflush (stdout
);
20749 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20750 if (quiet
== 0) fflush (stdout
);
20762 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20763 if (quiet
== 0) fflush (stdout
);
20775 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20776 if (quiet
== 0) fflush (stdout
);
20784 if (benchmark
== 1) break;
20786 stop_at_checkpoint ();
20790 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20791 if (quiet
== 0) fflush (stdout
);
20799 if (benchmark
== 1)
20811 //https://github.com/hashcat/hashcat/issues/302
20816 hc_thread_mutex_unlock (mux_display
);
20828 bool class_num (const u8 c
)
20830 return ((c
>= '0') && (c
<= '9'));
20833 bool class_lower (const u8 c
)
20835 return ((c
>= 'a') && (c
<= 'z'));
20838 bool class_upper (const u8 c
)
20840 return ((c
>= 'A') && (c
<= 'Z'));
20843 bool class_alpha (const u8 c
)
20845 return (class_lower (c
) || class_upper (c
));
20848 int conv_ctoi (const u8 c
)
20854 else if (class_upper (c
))
20856 return c
- 'A' + 10;
20862 int conv_itoc (const u8 c
)
20870 return c
+ 'A' - 10;
20880 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20881 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20882 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20883 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20884 #define MAX_KERNEL_RULES 255
20885 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20886 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20887 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20889 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20890 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20891 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20892 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20894 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20899 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20901 switch (rule_buf
[rule_pos
])
20907 case RULE_OP_MANGLE_NOOP
:
20908 SET_NAME (rule
, rule_buf
[rule_pos
]);
20911 case RULE_OP_MANGLE_LREST
:
20912 SET_NAME (rule
, rule_buf
[rule_pos
]);
20915 case RULE_OP_MANGLE_UREST
:
20916 SET_NAME (rule
, rule_buf
[rule_pos
]);
20919 case RULE_OP_MANGLE_LREST_UFIRST
:
20920 SET_NAME (rule
, rule_buf
[rule_pos
]);
20923 case RULE_OP_MANGLE_UREST_LFIRST
:
20924 SET_NAME (rule
, rule_buf
[rule_pos
]);
20927 case RULE_OP_MANGLE_TREST
:
20928 SET_NAME (rule
, rule_buf
[rule_pos
]);
20931 case RULE_OP_MANGLE_TOGGLE_AT
:
20932 SET_NAME (rule
, rule_buf
[rule_pos
]);
20933 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20936 case RULE_OP_MANGLE_REVERSE
:
20937 SET_NAME (rule
, rule_buf
[rule_pos
]);
20940 case RULE_OP_MANGLE_DUPEWORD
:
20941 SET_NAME (rule
, rule_buf
[rule_pos
]);
20944 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20945 SET_NAME (rule
, rule_buf
[rule_pos
]);
20946 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20949 case RULE_OP_MANGLE_REFLECT
:
20950 SET_NAME (rule
, rule_buf
[rule_pos
]);
20953 case RULE_OP_MANGLE_ROTATE_LEFT
:
20954 SET_NAME (rule
, rule_buf
[rule_pos
]);
20957 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20958 SET_NAME (rule
, rule_buf
[rule_pos
]);
20961 case RULE_OP_MANGLE_APPEND
:
20962 SET_NAME (rule
, rule_buf
[rule_pos
]);
20963 SET_P0 (rule
, rule_buf
[rule_pos
]);
20966 case RULE_OP_MANGLE_PREPEND
:
20967 SET_NAME (rule
, rule_buf
[rule_pos
]);
20968 SET_P0 (rule
, rule_buf
[rule_pos
]);
20971 case RULE_OP_MANGLE_DELETE_FIRST
:
20972 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 case RULE_OP_MANGLE_DELETE_LAST
:
20976 SET_NAME (rule
, rule_buf
[rule_pos
]);
20979 case RULE_OP_MANGLE_DELETE_AT
:
20980 SET_NAME (rule
, rule_buf
[rule_pos
]);
20981 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20984 case RULE_OP_MANGLE_EXTRACT
:
20985 SET_NAME (rule
, rule_buf
[rule_pos
]);
20986 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20987 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20990 case RULE_OP_MANGLE_OMIT
:
20991 SET_NAME (rule
, rule_buf
[rule_pos
]);
20992 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20993 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20996 case RULE_OP_MANGLE_INSERT
:
20997 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20999 SET_P1 (rule
, rule_buf
[rule_pos
]);
21002 case RULE_OP_MANGLE_OVERSTRIKE
:
21003 SET_NAME (rule
, rule_buf
[rule_pos
]);
21004 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21005 SET_P1 (rule
, rule_buf
[rule_pos
]);
21008 case RULE_OP_MANGLE_TRUNCATE_AT
:
21009 SET_NAME (rule
, rule_buf
[rule_pos
]);
21010 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21013 case RULE_OP_MANGLE_REPLACE
:
21014 SET_NAME (rule
, rule_buf
[rule_pos
]);
21015 SET_P0 (rule
, rule_buf
[rule_pos
]);
21016 SET_P1 (rule
, rule_buf
[rule_pos
]);
21019 case RULE_OP_MANGLE_PURGECHAR
:
21023 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21027 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21029 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21032 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21033 SET_NAME (rule
, rule_buf
[rule_pos
]);
21034 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_SWITCH_FIRST
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21045 case RULE_OP_MANGLE_SWITCH_LAST
:
21046 SET_NAME (rule
, rule_buf
[rule_pos
]);
21049 case RULE_OP_MANGLE_SWITCH_AT
:
21050 SET_NAME (rule
, rule_buf
[rule_pos
]);
21051 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21052 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21055 case RULE_OP_MANGLE_CHR_SHIFTL
:
21056 SET_NAME (rule
, rule_buf
[rule_pos
]);
21057 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21060 case RULE_OP_MANGLE_CHR_SHIFTR
:
21061 SET_NAME (rule
, rule_buf
[rule_pos
]);
21062 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21065 case RULE_OP_MANGLE_CHR_INCR
:
21066 SET_NAME (rule
, rule_buf
[rule_pos
]);
21067 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21070 case RULE_OP_MANGLE_CHR_DECR
:
21071 SET_NAME (rule
, rule_buf
[rule_pos
]);
21072 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21075 case RULE_OP_MANGLE_REPLACE_NP1
:
21076 SET_NAME (rule
, rule_buf
[rule_pos
]);
21077 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21080 case RULE_OP_MANGLE_REPLACE_NM1
:
21081 SET_NAME (rule
, rule_buf
[rule_pos
]);
21082 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21085 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21086 SET_NAME (rule
, rule_buf
[rule_pos
]);
21087 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21090 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21091 SET_NAME (rule
, rule_buf
[rule_pos
]);
21092 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21095 case RULE_OP_MANGLE_TITLE
:
21096 SET_NAME (rule
, rule_buf
[rule_pos
]);
21105 if (rule_pos
< rule_len
) return (-1);
21110 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21114 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21118 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21122 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21126 case RULE_OP_MANGLE_NOOP
:
21127 rule_buf
[rule_pos
] = rule_cmd
;
21130 case RULE_OP_MANGLE_LREST
:
21131 rule_buf
[rule_pos
] = rule_cmd
;
21134 case RULE_OP_MANGLE_UREST
:
21135 rule_buf
[rule_pos
] = rule_cmd
;
21138 case RULE_OP_MANGLE_LREST_UFIRST
:
21139 rule_buf
[rule_pos
] = rule_cmd
;
21142 case RULE_OP_MANGLE_UREST_LFIRST
:
21143 rule_buf
[rule_pos
] = rule_cmd
;
21146 case RULE_OP_MANGLE_TREST
:
21147 rule_buf
[rule_pos
] = rule_cmd
;
21150 case RULE_OP_MANGLE_TOGGLE_AT
:
21151 rule_buf
[rule_pos
] = rule_cmd
;
21152 GET_P0_CONV (rule
);
21155 case RULE_OP_MANGLE_REVERSE
:
21156 rule_buf
[rule_pos
] = rule_cmd
;
21159 case RULE_OP_MANGLE_DUPEWORD
:
21160 rule_buf
[rule_pos
] = rule_cmd
;
21163 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21164 rule_buf
[rule_pos
] = rule_cmd
;
21165 GET_P0_CONV (rule
);
21168 case RULE_OP_MANGLE_REFLECT
:
21169 rule_buf
[rule_pos
] = rule_cmd
;
21172 case RULE_OP_MANGLE_ROTATE_LEFT
:
21173 rule_buf
[rule_pos
] = rule_cmd
;
21176 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21177 rule_buf
[rule_pos
] = rule_cmd
;
21180 case RULE_OP_MANGLE_APPEND
:
21181 rule_buf
[rule_pos
] = rule_cmd
;
21185 case RULE_OP_MANGLE_PREPEND
:
21186 rule_buf
[rule_pos
] = rule_cmd
;
21190 case RULE_OP_MANGLE_DELETE_FIRST
:
21191 rule_buf
[rule_pos
] = rule_cmd
;
21194 case RULE_OP_MANGLE_DELETE_LAST
:
21195 rule_buf
[rule_pos
] = rule_cmd
;
21198 case RULE_OP_MANGLE_DELETE_AT
:
21199 rule_buf
[rule_pos
] = rule_cmd
;
21200 GET_P0_CONV (rule
);
21203 case RULE_OP_MANGLE_EXTRACT
:
21204 rule_buf
[rule_pos
] = rule_cmd
;
21205 GET_P0_CONV (rule
);
21206 GET_P1_CONV (rule
);
21209 case RULE_OP_MANGLE_OMIT
:
21210 rule_buf
[rule_pos
] = rule_cmd
;
21211 GET_P0_CONV (rule
);
21212 GET_P1_CONV (rule
);
21215 case RULE_OP_MANGLE_INSERT
:
21216 rule_buf
[rule_pos
] = rule_cmd
;
21217 GET_P0_CONV (rule
);
21221 case RULE_OP_MANGLE_OVERSTRIKE
:
21222 rule_buf
[rule_pos
] = rule_cmd
;
21223 GET_P0_CONV (rule
);
21227 case RULE_OP_MANGLE_TRUNCATE_AT
:
21228 rule_buf
[rule_pos
] = rule_cmd
;
21229 GET_P0_CONV (rule
);
21232 case RULE_OP_MANGLE_REPLACE
:
21233 rule_buf
[rule_pos
] = rule_cmd
;
21238 case RULE_OP_MANGLE_PURGECHAR
:
21242 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21246 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21248 GET_P0_CONV (rule
);
21251 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21252 rule_buf
[rule_pos
] = rule_cmd
;
21253 GET_P0_CONV (rule
);
21256 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21260 case RULE_OP_MANGLE_SWITCH_FIRST
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21264 case RULE_OP_MANGLE_SWITCH_LAST
:
21265 rule_buf
[rule_pos
] = rule_cmd
;
21268 case RULE_OP_MANGLE_SWITCH_AT
:
21269 rule_buf
[rule_pos
] = rule_cmd
;
21270 GET_P0_CONV (rule
);
21271 GET_P1_CONV (rule
);
21274 case RULE_OP_MANGLE_CHR_SHIFTL
:
21275 rule_buf
[rule_pos
] = rule_cmd
;
21276 GET_P0_CONV (rule
);
21279 case RULE_OP_MANGLE_CHR_SHIFTR
:
21280 rule_buf
[rule_pos
] = rule_cmd
;
21281 GET_P0_CONV (rule
);
21284 case RULE_OP_MANGLE_CHR_INCR
:
21285 rule_buf
[rule_pos
] = rule_cmd
;
21286 GET_P0_CONV (rule
);
21289 case RULE_OP_MANGLE_CHR_DECR
:
21290 rule_buf
[rule_pos
] = rule_cmd
;
21291 GET_P0_CONV (rule
);
21294 case RULE_OP_MANGLE_REPLACE_NP1
:
21295 rule_buf
[rule_pos
] = rule_cmd
;
21296 GET_P0_CONV (rule
);
21299 case RULE_OP_MANGLE_REPLACE_NM1
:
21300 rule_buf
[rule_pos
] = rule_cmd
;
21301 GET_P0_CONV (rule
);
21304 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21305 rule_buf
[rule_pos
] = rule_cmd
;
21306 GET_P0_CONV (rule
);
21309 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21310 rule_buf
[rule_pos
] = rule_cmd
;
21311 GET_P0_CONV (rule
);
21314 case RULE_OP_MANGLE_TITLE
:
21315 rule_buf
[rule_pos
] = rule_cmd
;
21319 return rule_pos
- 1;
21337 * CPU rules : this is from hashcat sources, cpu based rules
21340 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21341 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21343 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21344 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21345 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21347 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21348 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21349 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21351 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21355 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21360 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21364 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21369 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21373 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21378 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21383 for (l
= 0; l
< arr_len
; l
++)
21385 r
= arr_len
- 1 - l
;
21389 MANGLE_SWITCH (arr
, l
, r
);
21395 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21397 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21399 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21401 return (arr_len
* 2);
21404 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21406 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21408 int orig_len
= arr_len
;
21412 for (i
= 0; i
< times
; i
++)
21414 memcpy (&arr
[arr_len
], arr
, orig_len
);
21416 arr_len
+= orig_len
;
21422 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21424 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21426 mangle_double (arr
, arr_len
);
21428 mangle_reverse (arr
+ arr_len
, arr_len
);
21430 return (arr_len
* 2);
21433 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21438 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21440 MANGLE_SWITCH (arr
, l
, r
);
21446 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21451 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21453 MANGLE_SWITCH (arr
, l
, r
);
21459 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21461 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21465 return (arr_len
+ 1);
21468 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21470 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21474 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21476 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21481 return (arr_len
+ 1);
21484 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21486 if (upos
>= arr_len
) return (arr_len
);
21490 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21492 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21495 return (arr_len
- 1);
21498 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21500 if (upos
>= arr_len
) return (arr_len
);
21502 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21506 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21508 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21514 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21516 if (upos
>= arr_len
) return (arr_len
);
21518 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21522 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21524 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21527 return (arr_len
- ulen
);
21530 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21532 if (upos
>= arr_len
) return (arr_len
);
21534 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21538 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21540 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21545 return (arr_len
+ 1);
21548 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
)
21550 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21552 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21554 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21556 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21558 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21560 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21562 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21564 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21566 return (arr_len
+ arr2_cpy
);
21569 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21571 if (upos
>= arr_len
) return (arr_len
);
21578 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21580 if (upos
>= arr_len
) return (arr_len
);
21582 memset (arr
+ upos
, 0, arr_len
- upos
);
21587 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21591 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21593 if (arr
[arr_pos
] != oldc
) continue;
21595 arr
[arr_pos
] = newc
;
21601 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21607 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21609 if (arr
[arr_pos
] == c
) continue;
21611 arr
[ret_len
] = arr
[arr_pos
];
21619 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21621 if (ulen
> arr_len
) return (arr_len
);
21623 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21625 char cs
[100] = { 0 };
21627 memcpy (cs
, arr
, ulen
);
21631 for (i
= 0; i
< ulen
; i
++)
21635 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21641 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21643 if (ulen
> arr_len
) return (arr_len
);
21645 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21647 int upos
= arr_len
- ulen
;
21651 for (i
= 0; i
< ulen
; i
++)
21653 char c
= arr
[upos
+ i
];
21655 arr_len
= mangle_append (arr
, arr_len
, c
);
21661 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21663 if ( arr_len
== 0) return (arr_len
);
21664 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21666 char c
= arr
[upos
];
21670 for (i
= 0; i
< ulen
; i
++)
21672 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21678 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21680 if ( arr_len
== 0) return (arr_len
);
21681 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21685 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21687 int new_pos
= arr_pos
* 2;
21689 arr
[new_pos
] = arr
[arr_pos
];
21691 arr
[new_pos
+ 1] = arr
[arr_pos
];
21694 return (arr_len
* 2);
21697 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21699 if (upos
>= arr_len
) return (arr_len
);
21700 if (upos2
>= arr_len
) return (arr_len
);
21702 MANGLE_SWITCH (arr
, upos
, upos2
);
21707 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21709 MANGLE_SWITCH (arr
, upos
, upos2
);
21714 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21716 if (upos
>= arr_len
) return (arr_len
);
21723 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21725 if (upos
>= arr_len
) return (arr_len
);
21732 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21734 if (upos
>= arr_len
) return (arr_len
);
21741 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21743 if (upos
>= arr_len
) return (arr_len
);
21750 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21752 int upper_next
= 1;
21756 for (pos
= 0; pos
< arr_len
; pos
++)
21758 if (arr
[pos
] == ' ')
21769 MANGLE_UPPER_AT (arr
, pos
);
21773 MANGLE_LOWER_AT (arr
, pos
);
21780 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21782 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21788 for (j
= 0; j
< rp_gen_num
; j
++)
21795 switch ((char) get_random_num (0, 9))
21798 r
= get_random_num (0, sizeof (grp_op_nop
));
21799 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21803 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21804 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21805 p1
= get_random_num (0, sizeof (grp_pos
));
21806 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21810 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21811 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21812 p1
= get_random_num (1, 6);
21813 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21817 r
= get_random_num (0, sizeof (grp_op_chr
));
21818 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21819 p1
= get_random_num (0x20, 0x7e);
21820 rule_buf
[rule_pos
++] = (char) p1
;
21824 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21825 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21826 p1
= get_random_num (0x20, 0x7e);
21827 rule_buf
[rule_pos
++] = (char) p1
;
21828 p2
= get_random_num (0x20, 0x7e);
21830 p2
= get_random_num (0x20, 0x7e);
21831 rule_buf
[rule_pos
++] = (char) p2
;
21835 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21836 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21837 p1
= get_random_num (0, sizeof (grp_pos
));
21838 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21839 p2
= get_random_num (0x20, 0x7e);
21840 rule_buf
[rule_pos
++] = (char) p2
;
21844 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21845 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21846 p1
= get_random_num (0, sizeof (grp_pos
));
21847 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21848 p2
= get_random_num (0, sizeof (grp_pos
));
21850 p2
= get_random_num (0, sizeof (grp_pos
));
21851 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21855 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21856 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21857 p1
= get_random_num (0, sizeof (grp_pos
));
21858 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21859 p2
= get_random_num (1, sizeof (grp_pos
));
21861 p2
= get_random_num (1, sizeof (grp_pos
));
21862 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21866 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21867 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21868 p1
= get_random_num (0, sizeof (grp_pos
));
21869 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21870 p2
= get_random_num (1, sizeof (grp_pos
));
21871 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21872 p3
= get_random_num (0, sizeof (grp_pos
));
21873 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21881 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21883 char mem
[BLOCK_SIZE
] = { 0 };
21885 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21887 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21889 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21891 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21893 int out_len
= in_len
;
21894 int mem_len
= in_len
;
21896 memcpy (out
, in
, out_len
);
21900 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21905 switch (rule
[rule_pos
])
21910 case RULE_OP_MANGLE_NOOP
:
21913 case RULE_OP_MANGLE_LREST
:
21914 out_len
= mangle_lrest (out
, out_len
);
21917 case RULE_OP_MANGLE_UREST
:
21918 out_len
= mangle_urest (out
, out_len
);
21921 case RULE_OP_MANGLE_LREST_UFIRST
:
21922 out_len
= mangle_lrest (out
, out_len
);
21923 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21926 case RULE_OP_MANGLE_UREST_LFIRST
:
21927 out_len
= mangle_urest (out
, out_len
);
21928 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21931 case RULE_OP_MANGLE_TREST
:
21932 out_len
= mangle_trest (out
, out_len
);
21935 case RULE_OP_MANGLE_TOGGLE_AT
:
21936 NEXT_RULEPOS (rule_pos
);
21937 NEXT_RPTOI (rule
, rule_pos
, upos
);
21938 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21941 case RULE_OP_MANGLE_REVERSE
:
21942 out_len
= mangle_reverse (out
, out_len
);
21945 case RULE_OP_MANGLE_DUPEWORD
:
21946 out_len
= mangle_double (out
, out_len
);
21949 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21950 NEXT_RULEPOS (rule_pos
);
21951 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21952 out_len
= mangle_double_times (out
, out_len
, ulen
);
21955 case RULE_OP_MANGLE_REFLECT
:
21956 out_len
= mangle_reflect (out
, out_len
);
21959 case RULE_OP_MANGLE_ROTATE_LEFT
:
21960 mangle_rotate_left (out
, out_len
);
21963 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21964 mangle_rotate_right (out
, out_len
);
21967 case RULE_OP_MANGLE_APPEND
:
21968 NEXT_RULEPOS (rule_pos
);
21969 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21972 case RULE_OP_MANGLE_PREPEND
:
21973 NEXT_RULEPOS (rule_pos
);
21974 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21977 case RULE_OP_MANGLE_DELETE_FIRST
:
21978 out_len
= mangle_delete_at (out
, out_len
, 0);
21981 case RULE_OP_MANGLE_DELETE_LAST
:
21982 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21985 case RULE_OP_MANGLE_DELETE_AT
:
21986 NEXT_RULEPOS (rule_pos
);
21987 NEXT_RPTOI (rule
, rule_pos
, upos
);
21988 out_len
= mangle_delete_at (out
, out_len
, upos
);
21991 case RULE_OP_MANGLE_EXTRACT
:
21992 NEXT_RULEPOS (rule_pos
);
21993 NEXT_RPTOI (rule
, rule_pos
, upos
);
21994 NEXT_RULEPOS (rule_pos
);
21995 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21996 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21999 case RULE_OP_MANGLE_OMIT
:
22000 NEXT_RULEPOS (rule_pos
);
22001 NEXT_RPTOI (rule
, rule_pos
, upos
);
22002 NEXT_RULEPOS (rule_pos
);
22003 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22004 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22007 case RULE_OP_MANGLE_INSERT
:
22008 NEXT_RULEPOS (rule_pos
);
22009 NEXT_RPTOI (rule
, rule_pos
, upos
);
22010 NEXT_RULEPOS (rule_pos
);
22011 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22014 case RULE_OP_MANGLE_OVERSTRIKE
:
22015 NEXT_RULEPOS (rule_pos
);
22016 NEXT_RPTOI (rule
, rule_pos
, upos
);
22017 NEXT_RULEPOS (rule_pos
);
22018 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22021 case RULE_OP_MANGLE_TRUNCATE_AT
:
22022 NEXT_RULEPOS (rule_pos
);
22023 NEXT_RPTOI (rule
, rule_pos
, upos
);
22024 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22027 case RULE_OP_MANGLE_REPLACE
:
22028 NEXT_RULEPOS (rule_pos
);
22029 NEXT_RULEPOS (rule_pos
);
22030 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22033 case RULE_OP_MANGLE_PURGECHAR
:
22034 NEXT_RULEPOS (rule_pos
);
22035 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22038 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22042 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22043 NEXT_RULEPOS (rule_pos
);
22044 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22045 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22048 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22049 NEXT_RULEPOS (rule_pos
);
22050 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22051 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22054 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22055 out_len
= mangle_dupechar (out
, out_len
);
22058 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22059 NEXT_RULEPOS (rule_pos
);
22060 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22061 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22064 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22065 NEXT_RULEPOS (rule_pos
);
22066 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22067 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22070 case RULE_OP_MANGLE_SWITCH_FIRST
:
22071 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22074 case RULE_OP_MANGLE_SWITCH_LAST
:
22075 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22078 case RULE_OP_MANGLE_SWITCH_AT
:
22079 NEXT_RULEPOS (rule_pos
);
22080 NEXT_RPTOI (rule
, rule_pos
, upos
);
22081 NEXT_RULEPOS (rule_pos
);
22082 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22083 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22086 case RULE_OP_MANGLE_CHR_SHIFTL
:
22087 NEXT_RULEPOS (rule_pos
);
22088 NEXT_RPTOI (rule
, rule_pos
, upos
);
22089 mangle_chr_shiftl (out
, out_len
, upos
);
22092 case RULE_OP_MANGLE_CHR_SHIFTR
:
22093 NEXT_RULEPOS (rule_pos
);
22094 NEXT_RPTOI (rule
, rule_pos
, upos
);
22095 mangle_chr_shiftr (out
, out_len
, upos
);
22098 case RULE_OP_MANGLE_CHR_INCR
:
22099 NEXT_RULEPOS (rule_pos
);
22100 NEXT_RPTOI (rule
, rule_pos
, upos
);
22101 mangle_chr_incr (out
, out_len
, upos
);
22104 case RULE_OP_MANGLE_CHR_DECR
:
22105 NEXT_RULEPOS (rule_pos
);
22106 NEXT_RPTOI (rule
, rule_pos
, upos
);
22107 mangle_chr_decr (out
, out_len
, upos
);
22110 case RULE_OP_MANGLE_REPLACE_NP1
:
22111 NEXT_RULEPOS (rule_pos
);
22112 NEXT_RPTOI (rule
, rule_pos
, upos
);
22113 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22116 case RULE_OP_MANGLE_REPLACE_NM1
:
22117 NEXT_RULEPOS (rule_pos
);
22118 NEXT_RPTOI (rule
, rule_pos
, upos
);
22119 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22122 case RULE_OP_MANGLE_TITLE
:
22123 out_len
= mangle_title (out
, out_len
);
22126 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22127 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22128 NEXT_RULEPOS (rule_pos
);
22129 NEXT_RPTOI (rule
, rule_pos
, upos
);
22130 NEXT_RULEPOS (rule_pos
);
22131 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22132 NEXT_RULEPOS (rule_pos
);
22133 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22134 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22137 case RULE_OP_MANGLE_APPEND_MEMORY
:
22138 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22139 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22140 memcpy (out
+ out_len
, mem
, mem_len
);
22141 out_len
+= mem_len
;
22144 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22145 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22146 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22147 memcpy (mem
+ mem_len
, out
, out_len
);
22148 out_len
+= mem_len
;
22149 memcpy (out
, mem
, out_len
);
22152 case RULE_OP_MEMORIZE_WORD
:
22153 memcpy (mem
, out
, out_len
);
22157 case RULE_OP_REJECT_LESS
:
22158 NEXT_RULEPOS (rule_pos
);
22159 NEXT_RPTOI (rule
, rule_pos
, upos
);
22160 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22163 case RULE_OP_REJECT_GREATER
:
22164 NEXT_RULEPOS (rule_pos
);
22165 NEXT_RPTOI (rule
, rule_pos
, upos
);
22166 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22169 case RULE_OP_REJECT_CONTAIN
:
22170 NEXT_RULEPOS (rule_pos
);
22171 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22174 case RULE_OP_REJECT_NOT_CONTAIN
:
22175 NEXT_RULEPOS (rule_pos
);
22176 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22179 case RULE_OP_REJECT_EQUAL_FIRST
:
22180 NEXT_RULEPOS (rule_pos
);
22181 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22184 case RULE_OP_REJECT_EQUAL_LAST
:
22185 NEXT_RULEPOS (rule_pos
);
22186 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22189 case RULE_OP_REJECT_EQUAL_AT
:
22190 NEXT_RULEPOS (rule_pos
);
22191 NEXT_RPTOI (rule
, rule_pos
, upos
);
22192 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22193 NEXT_RULEPOS (rule_pos
);
22194 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22197 case RULE_OP_REJECT_CONTAINS
:
22198 NEXT_RULEPOS (rule_pos
);
22199 NEXT_RPTOI (rule
, rule_pos
, upos
);
22200 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22201 NEXT_RULEPOS (rule_pos
);
22202 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22203 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22206 case RULE_OP_REJECT_MEMORY
:
22207 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22211 return (RULE_RC_SYNTAX_ERROR
);
22216 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);