2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3068 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3069 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3071 #if defined(LINUX) && defined(HAVE_NVML)
3074 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
3079 #if defined(WIN) && defined(HAVE_NVAPI)
3081 #endif // WIN && HAVE_NVAPI
3083 #endif // HAVE_NVML || HAVE_NVAPI
3088 int hm_get_temperature_with_device_id (const uint device_id
)
3090 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3093 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3097 if (data
.hm_device
[device_id
].od_version
== 5)
3099 ADLTemperature Temperature
;
3101 Temperature
.iSize
= sizeof (ADLTemperature
);
3103 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3105 return Temperature
.iTemperature
/ 1000;
3107 else if (data
.hm_device
[device_id
].od_version
== 6)
3109 int Temperature
= 0;
3111 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3113 return Temperature
/ 1000;
3119 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3120 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3122 #if defined(LINUX) && defined(HAVE_NVML)
3123 int temperature
= 0;
3125 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3130 #if defined(WIN) && defined(HAVE_NVAPI)
3131 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3133 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3134 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3135 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3136 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3138 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3140 return pThermalSettings
.sensor
[0].currentTemp
;
3141 #endif // WIN && HAVE_NVAPI
3143 #endif // HAVE_NVML || HAVE_NVAPI
3148 int hm_get_fanspeed_with_device_id (const uint device_id
)
3150 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3151 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3153 if (data
.hm_device
[device_id
].fan_supported
== 1)
3156 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3160 if (data
.hm_device
[device_id
].od_version
== 5)
3162 ADLFanSpeedValue lpFanSpeedValue
;
3164 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3166 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3167 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3168 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3170 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3172 return lpFanSpeedValue
.iFanSpeed
;
3174 else // od_version == 6
3176 ADLOD6FanSpeedInfo faninfo
;
3178 memset (&faninfo
, 0, sizeof (faninfo
));
3180 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3182 return faninfo
.iFanSpeedPercent
;
3188 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3189 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3191 #if defined(LINUX) && defined(HAVE_NVML)
3194 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3199 #if defined(WIN) && defined(HAVE_NVAPI)
3200 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3202 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3204 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3206 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3209 #endif // HAVE_NVML || HAVE_NVAPI
3215 int hm_get_utilization_with_device_id (const uint device_id
)
3217 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3220 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3224 ADLPMActivity PMActivity
;
3226 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3228 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3230 return PMActivity
.iActivityPercent
;
3235 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3236 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3238 #if defined(LINUX) && defined(HAVE_NVML)
3239 nvmlUtilization_t utilization
;
3241 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3243 return utilization
.gpu
;
3246 #if defined(WIN) && defined(HAVE_NVAPI)
3247 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3249 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3251 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3253 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3256 #endif // HAVE_NVML || HAVE_NVAPI
3261 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3263 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3266 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3270 ADLPMActivity PMActivity
;
3272 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3274 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3276 return PMActivity
.iMemoryClock
/ 100;
3281 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3282 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3284 #if defined(LINUX) && defined(HAVE_NVML)
3287 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3292 #if defined(WIN) && defined(HAVE_NVAPI)
3293 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3295 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3296 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3298 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3300 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_MEMORY
].frequency
/ 1000;
3303 #endif // HAVE_NVML || HAVE_NVAPI
3308 int hm_get_corespeed_with_device_id (const uint device_id
)
3310 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3313 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3317 ADLPMActivity PMActivity
;
3319 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3321 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3323 return PMActivity
.iEngineClock
/ 100;
3328 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3329 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3331 #if defined(LINUX) && defined(HAVE_NVML)
3334 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3339 #if defined(WIN) && defined(HAVE_NVAPI)
3340 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3342 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3343 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3345 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3347 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS
].frequency
/ 1000;
3350 #endif // HAVE_NVML || HAVE_NVAPI
3356 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3358 if (data
.hm_device
[device_id
].fan_supported
== 1)
3362 if (data
.hm_device
[device_id
].od_version
== 5)
3364 ADLFanSpeedValue lpFanSpeedValue
;
3366 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3368 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3369 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3370 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3371 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3373 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3377 else // od_version == 6
3379 ADLOD6FanSpeedValue fan_speed_value
;
3381 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3383 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3384 fan_speed_value
.iFanSpeed
= fanspeed
;
3386 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3397 // helper function for status display
3399 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3401 #define VALUE_NOT_AVAILABLE "N/A"
3405 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3409 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3412 #endif // HAVE_HWMON
3418 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3420 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3422 if (css_cnt
> SP_PW_MAX
)
3424 log_error ("ERROR: mask length is too long");
3429 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3431 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3433 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3434 uint cs_len
= css
[css_pos
].cs_len
;
3436 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3438 uint c
= cs_buf
[cs_pos
] & 0xff;
3445 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3447 cs_t
*cs
= &css
[css_cnt
];
3449 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3451 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3455 for (i
= 0; i
< cs
->cs_len
; i
++)
3457 const uint u
= cs
->cs_buf
[i
];
3462 for (i
= 0; i
< in_len
; i
++)
3464 uint u
= in_buf
[i
] & 0xff;
3466 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3468 if (css_uniq
[u
] == 1) continue;
3472 cs
->cs_buf
[cs
->cs_len
] = u
;
3480 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3484 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3486 uint p0
= in_buf
[in_pos
] & 0xff;
3488 if (interpret
== 1 && p0
== '?')
3492 if (in_pos
== in_len
) break;
3494 uint p1
= in_buf
[in_pos
] & 0xff;
3498 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3500 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3502 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3504 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3506 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3508 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3510 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3511 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3513 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3514 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3516 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3517 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3519 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3520 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3522 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3524 default: log_error ("Syntax error: %s", in_buf
);
3530 if (data
.hex_charset
)
3534 if (in_pos
== in_len
)
3536 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3541 uint p1
= in_buf
[in_pos
] & 0xff;
3543 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3545 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3552 chr
= hex_convert (p1
) << 0;
3553 chr
|= hex_convert (p0
) << 4;
3555 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3561 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3567 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3571 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3573 sum
*= css
[css_pos
].cs_len
;
3579 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3581 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3586 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3588 char p0
= mask_buf
[mask_pos
];
3594 if (mask_pos
== mask_len
) break;
3596 char p1
= mask_buf
[mask_pos
];
3602 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3604 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3606 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3608 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3610 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3612 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3614 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3615 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3617 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3618 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3620 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3621 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3623 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3624 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3626 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3628 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3634 if (data
.hex_charset
)
3638 // if there is no 2nd hex character, show an error:
3640 if (mask_pos
== mask_len
)
3642 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3647 char p1
= mask_buf
[mask_pos
];
3649 // if they are not valid hex character, show an error:
3651 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3653 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3660 chr
|= hex_convert (p1
) << 0;
3661 chr
|= hex_convert (p0
) << 4;
3663 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3669 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3676 log_error ("ERROR: invalid mask length (0)");
3686 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3688 for (int i
= 0; i
< css_cnt
; i
++)
3690 uint len
= css
[i
].cs_len
;
3691 u64 next
= val
/ len
;
3692 uint pos
= val
% len
;
3693 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3698 void mp_cut_at (char *mask
, uint max
)
3702 uint mask_len
= strlen (mask
);
3704 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3706 if (mask
[i
] == '?') i
++;
3712 void mp_setup_sys (cs_t
*mp_sys
)
3716 uint donec
[CHARSIZ
] = { 0 };
3718 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3719 mp_sys
[0].cs_buf
[pos
++] = chr
;
3720 mp_sys
[0].cs_len
= pos
; }
3722 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3723 mp_sys
[1].cs_buf
[pos
++] = chr
;
3724 mp_sys
[1].cs_len
= pos
; }
3726 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3727 mp_sys
[2].cs_buf
[pos
++] = chr
;
3728 mp_sys
[2].cs_len
= pos
; }
3730 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3731 mp_sys
[3].cs_buf
[pos
++] = chr
;
3732 mp_sys
[3].cs_len
= pos
; }
3734 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3735 mp_sys
[4].cs_len
= pos
; }
3737 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3738 mp_sys
[5].cs_len
= pos
; }
3741 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3743 FILE *fp
= fopen (buf
, "rb");
3745 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3747 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3751 char mp_file
[1024] = { 0 };
3753 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3757 len
= in_superchop (mp_file
);
3761 log_info ("WARNING: charset file corrupted");
3763 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3767 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3772 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3774 mp_usr
[index
].cs_len
= 0;
3776 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3779 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3781 char *new_mask_buf
= (char *) mymalloc (256);
3787 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3789 if (css_pos
== len
) break;
3791 char p0
= mask_buf
[mask_pos
];
3793 new_mask_buf
[mask_pos
] = p0
;
3799 if (mask_pos
== mask_len
) break;
3801 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3805 if (data
.hex_charset
)
3809 if (mask_pos
== mask_len
)
3811 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3816 char p1
= mask_buf
[mask_pos
];
3818 // if they are not valid hex character, show an error:
3820 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3822 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3827 new_mask_buf
[mask_pos
] = p1
;
3832 if (css_pos
== len
) return (new_mask_buf
);
3834 myfree (new_mask_buf
);
3843 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3849 for (i
= start
; i
< stop
; i
++)
3851 sum
*= root_css_buf
[i
].cs_len
;
3857 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3861 cs_t
*cs
= &root_css_buf
[start
];
3865 for (i
= start
; i
< stop
; i
++)
3867 const u64 m
= v
% cs
->cs_len
;
3868 const u64 d
= v
/ cs
->cs_len
;
3872 const uint k
= cs
->cs_buf
[m
];
3874 pw_buf
[i
- start
] = (char) k
;
3876 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3880 int sp_comp_val (const void *p1
, const void *p2
)
3882 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3883 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3885 return b2
->val
- b1
->val
;
3888 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
)
3895 * Initialize hcstats
3898 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3900 u64
*root_stats_ptr
= root_stats_buf
;
3902 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3904 for (i
= 0; i
< SP_PW_MAX
; i
++)
3906 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3908 root_stats_ptr
+= CHARSIZ
;
3911 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3913 u64
*markov_stats_ptr
= markov_stats_buf
;
3915 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3917 for (i
= 0; i
< SP_PW_MAX
; i
++)
3919 for (j
= 0; j
< CHARSIZ
; j
++)
3921 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3923 markov_stats_ptr
+= CHARSIZ
;
3933 char hcstat_tmp
[256] = { 0 };
3935 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3937 hcstat
= hcstat_tmp
;
3940 FILE *fd
= fopen (hcstat
, "rb");
3944 log_error ("%s: %s", hcstat
, strerror (errno
));
3949 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3951 log_error ("%s: Could not load data", hcstat
);
3958 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3960 log_error ("%s: Could not load data", hcstat
);
3970 * Markov modifier of hcstat_table on user request
3975 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3976 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3981 /* Add all stats to first position */
3983 for (i
= 1; i
< SP_PW_MAX
; i
++)
3985 u64
*out
= root_stats_buf_by_pos
[0];
3986 u64
*in
= root_stats_buf_by_pos
[i
];
3988 for (j
= 0; j
< CHARSIZ
; j
++)
3994 for (i
= 1; i
< SP_PW_MAX
; i
++)
3996 u64
*out
= markov_stats_buf_by_key
[0][0];
3997 u64
*in
= markov_stats_buf_by_key
[i
][0];
3999 for (j
= 0; j
< CHARSIZ
; j
++)
4001 for (k
= 0; k
< CHARSIZ
; k
++)
4008 /* copy them to all pw_positions */
4010 for (i
= 1; i
< SP_PW_MAX
; i
++)
4012 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4015 for (i
= 1; i
< SP_PW_MAX
; i
++)
4017 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4025 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4027 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4029 for (i
= 0; i
< SP_PW_MAX
; i
++)
4031 root_table_buf_by_pos
[i
] = root_table_ptr
;
4033 root_table_ptr
+= CHARSIZ
;
4036 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4038 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4040 for (i
= 0; i
< SP_PW_MAX
; i
++)
4042 for (j
= 0; j
< CHARSIZ
; j
++)
4044 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4046 markov_table_ptr
+= CHARSIZ
;
4051 * Convert hcstat to tables
4054 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4056 uint key
= i
% CHARSIZ
;
4058 root_table_buf
[i
].key
= key
;
4059 root_table_buf
[i
].val
= root_stats_buf
[i
];
4062 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4064 uint key
= i
% CHARSIZ
;
4066 markov_table_buf
[i
].key
= key
;
4067 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4070 myfree (root_stats_buf
);
4071 myfree (markov_stats_buf
);
4077 for (i
= 0; i
< SP_PW_MAX
; i
++)
4079 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4082 for (i
= 0; i
< SP_PW_MAX
; i
++)
4084 for (j
= 0; j
< CHARSIZ
; j
++)
4086 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4091 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
])
4094 * Convert tables to css
4097 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4099 uint pw_pos
= i
/ CHARSIZ
;
4101 cs_t
*cs
= &root_css_buf
[pw_pos
];
4103 if (cs
->cs_len
== threshold
) continue;
4105 uint key
= root_table_buf
[i
].key
;
4107 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4109 cs
->cs_buf
[cs
->cs_len
] = key
;
4115 * Convert table to css
4118 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4120 uint c
= i
/ CHARSIZ
;
4122 cs_t
*cs
= &markov_css_buf
[c
];
4124 if (cs
->cs_len
== threshold
) continue;
4126 uint pw_pos
= c
/ CHARSIZ
;
4128 uint key
= markov_table_buf
[i
].key
;
4130 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4132 cs
->cs_buf
[cs
->cs_len
] = key
;
4138 for (uint i = 0; i < 8; i++)
4140 for (uint j = 0x20; j < 0x80; j++)
4142 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4144 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4146 for (uint k = 0; k < 10; k++)
4148 printf (" %u\n", ptr->cs_buf[k]);
4155 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4157 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4159 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4169 for (uint j
= 1; j
< CHARSIZ
; j
++)
4179 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4181 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4183 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4185 out
+= CHARSIZ
* CHARSIZ
;
4186 in
+= CHARSIZ
* CHARSIZ
;
4188 for (uint j
= 0; j
< CHARSIZ
; j
++)
4195 for (uint k
= 1; k
< CHARSIZ
; k
++)
4207 * mixed shared functions
4210 void dump_hex (const u8
*s
, const int sz
)
4212 for (int i
= 0; i
< sz
; i
++)
4214 log_info_nn ("%02x ", s
[i
]);
4220 void usage_mini_print (const char *progname
)
4222 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4225 void usage_big_print (const char *progname
)
4227 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4230 char *get_exec_path ()
4232 int exec_path_len
= 1024;
4234 char *exec_path
= (char *) mymalloc (exec_path_len
);
4238 char tmp
[32] = { 0 };
4240 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4242 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4246 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4250 uint size
= exec_path_len
;
4252 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4254 log_error("! executable path buffer too small\n");
4259 const int len
= strlen (exec_path
);
4262 #error Your Operating System is not supported or detected
4270 char *get_install_dir (const char *progname
)
4272 char *install_dir
= mystrdup (progname
);
4273 char *last_slash
= NULL
;
4275 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4279 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4285 install_dir
[0] = '.';
4289 return (install_dir
);
4292 char *get_profile_dir (const char *homedir
)
4294 #define DOT_HASHCAT ".hashcat"
4296 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4298 char *profile_dir
= (char *) mymalloc (len
+ 1);
4300 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4305 char *get_session_dir (const char *profile_dir
)
4307 #define SESSIONS_FOLDER "sessions"
4309 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4311 char *session_dir
= (char *) mymalloc (len
+ 1);
4313 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4318 uint
count_lines (FILE *fd
)
4322 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4328 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4330 if (nread
< 1) continue;
4334 for (i
= 0; i
< nread
; i
++)
4336 if (prev
== '\n') cnt
++;
4347 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4351 FILE *fd
= fopen (filename
, "rb");
4355 log_error ("%s: %s", filename
, strerror (errno
));
4360 #define MAX_KEY_SIZE (1024 * 1024)
4362 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4364 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4370 for (int fpos
= 0; fpos
< nread
; fpos
++)
4372 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4374 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4375 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4376 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4377 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4379 if (kpos
>= 64) kpos
= 0;
4386 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4390 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4391 if (CPU_ISSET(core
, cpu_set
)) break;
4393 thread_affinity_policy_data_t policy
= { core
};
4395 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4397 if (data
.quiet
== 0)
4399 if (rc
!= KERN_SUCCESS
)
4401 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4409 void set_cpu_affinity (char *cpu_affinity
)
4412 DWORD_PTR aff_mask
= 0;
4420 char *devices
= strdup (cpu_affinity
);
4422 char *next
= strtok (devices
, ",");
4426 uint cpu_id
= atoi (next
);
4441 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4447 aff_mask
|= 1 << (cpu_id
- 1);
4449 CPU_SET ((cpu_id
- 1), &cpuset
);
4452 } while ((next
= strtok (NULL
, ",")) != NULL
);
4458 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4459 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4461 pthread_t thread
= pthread_self ();
4462 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4466 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4468 char *element
, *end
;
4470 end
= (char *) base
+ nmemb
* size
;
4472 for (element
= (char *) base
; element
< end
; element
+= size
)
4473 if (!compar (element
, key
))
4479 int sort_by_u32 (const void *v1
, const void *v2
)
4481 const u32
*s1
= (const u32
*) v1
;
4482 const u32
*s2
= (const u32
*) v2
;
4487 int sort_by_salt (const void *v1
, const void *v2
)
4489 const salt_t
*s1
= (const salt_t
*) v1
;
4490 const salt_t
*s2
= (const salt_t
*) v2
;
4492 const int res1
= s1
->salt_len
- s2
->salt_len
;
4494 if (res1
!= 0) return (res1
);
4496 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4498 if (res2
!= 0) return (res2
);
4506 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4507 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4514 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4515 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4521 int sort_by_salt_buf (const void *v1
, const void *v2
)
4523 const pot_t
*p1
= (const pot_t
*) v1
;
4524 const pot_t
*p2
= (const pot_t
*) v2
;
4526 const hash_t
*h1
= &p1
->hash
;
4527 const hash_t
*h2
= &p2
->hash
;
4529 const salt_t
*s1
= h1
->salt
;
4530 const salt_t
*s2
= h2
->salt
;
4536 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4537 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4543 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4545 const hash_t
*h1
= (const hash_t
*) v1
;
4546 const hash_t
*h2
= (const hash_t
*) v2
;
4548 const salt_t
*s1
= h1
->salt
;
4549 const salt_t
*s2
= h2
->salt
;
4551 // testphase: this should work
4556 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4557 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4560 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4561 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4562 if (s1->salt_len > s2->salt_len) return ( 1);
4563 if (s1->salt_len < s2->salt_len) return (-1);
4565 uint n = s1->salt_len;
4569 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4570 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4577 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4579 const hash_t
*h1
= (const hash_t
*) v1
;
4580 const hash_t
*h2
= (const hash_t
*) v2
;
4582 const salt_t
*s1
= h1
->salt
;
4583 const salt_t
*s2
= h2
->salt
;
4585 // 16 - 2 (since last 2 uints contain the digest)
4590 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4591 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4597 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4599 const hash_t
*h1
= (const hash_t
*) v1
;
4600 const hash_t
*h2
= (const hash_t
*) v2
;
4602 const void *d1
= h1
->digest
;
4603 const void *d2
= h2
->digest
;
4605 return data
.sort_by_digest (d1
, d2
);
4608 int sort_by_hash (const void *v1
, const void *v2
)
4610 const hash_t
*h1
= (const hash_t
*) v1
;
4611 const hash_t
*h2
= (const hash_t
*) v2
;
4615 const salt_t
*s1
= h1
->salt
;
4616 const salt_t
*s2
= h2
->salt
;
4618 int res
= sort_by_salt (s1
, s2
);
4620 if (res
!= 0) return (res
);
4623 const void *d1
= h1
->digest
;
4624 const void *d2
= h2
->digest
;
4626 return data
.sort_by_digest (d1
, d2
);
4629 int sort_by_pot (const void *v1
, const void *v2
)
4631 const pot_t
*p1
= (const pot_t
*) v1
;
4632 const pot_t
*p2
= (const pot_t
*) v2
;
4634 const hash_t
*h1
= &p1
->hash
;
4635 const hash_t
*h2
= &p2
->hash
;
4637 return sort_by_hash (h1
, h2
);
4640 int sort_by_mtime (const void *p1
, const void *p2
)
4642 const char **f1
= (const char **) p1
;
4643 const char **f2
= (const char **) p2
;
4645 struct stat s1
; stat (*f1
, &s1
);
4646 struct stat s2
; stat (*f2
, &s2
);
4648 return s2
.st_mtime
- s1
.st_mtime
;
4651 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4653 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4654 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4656 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4659 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4661 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4662 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4664 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4667 int sort_by_stringptr (const void *p1
, const void *p2
)
4669 const char **s1
= (const char **) p1
;
4670 const char **s2
= (const char **) p2
;
4672 return strcmp (*s1
, *s2
);
4675 int sort_by_dictstat (const void *s1
, const void *s2
)
4677 dictstat_t
*d1
= (dictstat_t
*) s1
;
4678 dictstat_t
*d2
= (dictstat_t
*) s2
;
4681 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4683 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4686 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4689 int sort_by_bitmap (const void *p1
, const void *p2
)
4691 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4692 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4694 return b1
->collisions
- b2
->collisions
;
4697 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4699 const u32
*d1
= (const u32
*) v1
;
4700 const u32
*d2
= (const u32
*) v2
;
4706 if (d1
[n
] > d2
[n
]) return ( 1);
4707 if (d1
[n
] < d2
[n
]) return (-1);
4713 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4715 const u32
*d1
= (const u32
*) v1
;
4716 const u32
*d2
= (const u32
*) v2
;
4722 if (d1
[n
] > d2
[n
]) return ( 1);
4723 if (d1
[n
] < d2
[n
]) return (-1);
4729 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4731 const u32
*d1
= (const u32
*) v1
;
4732 const u32
*d2
= (const u32
*) v2
;
4738 if (d1
[n
] > d2
[n
]) return ( 1);
4739 if (d1
[n
] < d2
[n
]) return (-1);
4745 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4747 const u32
*d1
= (const u32
*) v1
;
4748 const u32
*d2
= (const u32
*) v2
;
4754 if (d1
[n
] > d2
[n
]) return ( 1);
4755 if (d1
[n
] < d2
[n
]) return (-1);
4761 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4763 const u32
*d1
= (const u32
*) v1
;
4764 const u32
*d2
= (const u32
*) v2
;
4770 if (d1
[n
] > d2
[n
]) return ( 1);
4771 if (d1
[n
] < d2
[n
]) return (-1);
4777 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4779 const u32
*d1
= (const u32
*) v1
;
4780 const u32
*d2
= (const u32
*) v2
;
4786 if (d1
[n
] > d2
[n
]) return ( 1);
4787 if (d1
[n
] < d2
[n
]) return (-1);
4793 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4795 const u32
*d1
= (const u32
*) v1
;
4796 const u32
*d2
= (const u32
*) v2
;
4802 if (d1
[n
] > d2
[n
]) return ( 1);
4803 if (d1
[n
] < d2
[n
]) return (-1);
4809 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4811 const u32
*d1
= (const u32
*) v1
;
4812 const u32
*d2
= (const u32
*) v2
;
4818 if (d1
[n
] > d2
[n
]) return ( 1);
4819 if (d1
[n
] < d2
[n
]) return (-1);
4825 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4827 const u64
*d1
= (const u64
*) v1
;
4828 const u64
*d2
= (const u64
*) v2
;
4834 if (d1
[n
] > d2
[n
]) return ( 1);
4835 if (d1
[n
] < d2
[n
]) return (-1);
4841 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4843 const u64
*d1
= (const u64
*) v1
;
4844 const u64
*d2
= (const u64
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4859 const u64
*d1
= (const u64
*) v1
;
4860 const u64
*d2
= (const u64
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4878 const uint dgst_pos0
= data
.dgst_pos0
;
4879 const uint dgst_pos1
= data
.dgst_pos1
;
4880 const uint dgst_pos2
= data
.dgst_pos2
;
4881 const uint dgst_pos3
= data
.dgst_pos3
;
4883 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4884 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4885 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4886 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4887 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4888 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4889 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4890 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4895 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4897 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4898 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4900 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4902 if (res1
!= 0) return (res1
);
4907 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4909 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4910 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4912 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4914 if (res1
!= 0) return (res1
);
4916 const int res2
= t1
->attack_mode
4919 if (res2
!= 0) return (res2
);
4921 const int res3
= t1
->hash_type
4924 if (res3
!= 0) return (res3
);
4929 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
)
4931 uint outfile_autohex
= data
.outfile_autohex
;
4933 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4935 FILE *debug_fp
= NULL
;
4937 if (debug_file
!= NULL
)
4939 debug_fp
= fopen (debug_file
, "ab");
4941 lock_file (debug_fp
);
4948 if (debug_fp
== NULL
)
4950 log_info ("WARNING: Could not open debug-file for writing");
4954 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4956 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4958 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4961 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4963 if (debug_mode
== 4)
4965 fputc (':', debug_fp
);
4967 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4970 fputc ('\n', debug_fp
);
4972 if (debug_file
!= NULL
) fclose (debug_fp
);
4976 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4978 int needs_hexify
= 0;
4980 if (outfile_autohex
== 1)
4982 for (uint i
= 0; i
< plain_len
; i
++)
4984 if (plain_ptr
[i
] < 0x20)
4991 if (plain_ptr
[i
] > 0x7f)
5000 if (needs_hexify
== 1)
5002 fprintf (fp
, "$HEX[");
5004 for (uint i
= 0; i
< plain_len
; i
++)
5006 fprintf (fp
, "%02x", plain_ptr
[i
]);
5013 fwrite (plain_ptr
, plain_len
, 1, fp
);
5017 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
)
5019 uint outfile_format
= data
.outfile_format
;
5021 char separator
= data
.separator
;
5023 if (outfile_format
& OUTFILE_FMT_HASH
)
5025 fprintf (out_fp
, "%s", out_buf
);
5027 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5029 fputc (separator
, out_fp
);
5032 else if (data
.username
)
5034 if (username
!= NULL
)
5036 for (uint i
= 0; i
< user_len
; i
++)
5038 fprintf (out_fp
, "%c", username
[i
]);
5041 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5043 fputc (separator
, out_fp
);
5048 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5050 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5052 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5054 fputc (separator
, out_fp
);
5058 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5060 for (uint i
= 0; i
< plain_len
; i
++)
5062 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5065 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5067 fputc (separator
, out_fp
);
5071 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5074 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5079 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5081 fprintf (out_fp
, "%llu", crackpos
);
5086 fputc ('\n', out_fp
);
5089 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
)
5093 pot_key
.hash
.salt
= hashes_buf
->salt
;
5094 pot_key
.hash
.digest
= hashes_buf
->digest
;
5096 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5102 input_buf
[input_len
] = 0;
5105 unsigned char *username
= NULL
;
5110 user_t
*user
= hashes_buf
->hash_info
->user
;
5114 username
= (unsigned char *) (user
->user_name
);
5116 user_len
= user
->user_len
;
5120 // do output the line
5121 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5125 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5126 #define LM_MASKED_PLAIN "[notfound]"
5128 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
)
5134 pot_left_key
.hash
.salt
= hash_left
->salt
;
5135 pot_left_key
.hash
.digest
= hash_left
->digest
;
5137 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5141 uint weak_hash_found
= 0;
5143 pot_t pot_right_key
;
5145 pot_right_key
.hash
.salt
= hash_right
->salt
;
5146 pot_right_key
.hash
.digest
= hash_right
->digest
;
5148 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5150 if (pot_right_ptr
== NULL
)
5152 // special case, if "weak hash"
5154 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5156 weak_hash_found
= 1;
5158 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5160 // in theory this is not needed, but we are paranoia:
5162 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5163 pot_right_ptr
->plain_len
= 0;
5167 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5169 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
5174 // at least one half was found:
5178 input_buf
[input_len
] = 0;
5182 unsigned char *username
= NULL
;
5187 user_t
*user
= hash_left
->hash_info
->user
;
5191 username
= (unsigned char *) (user
->user_name
);
5193 user_len
= user
->user_len
;
5197 // mask the part which was not found
5199 uint left_part_masked
= 0;
5200 uint right_part_masked
= 0;
5202 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5204 if (pot_left_ptr
== NULL
)
5206 left_part_masked
= 1;
5208 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5210 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5212 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5213 pot_left_ptr
->plain_len
= mask_plain_len
;
5216 if (pot_right_ptr
== NULL
)
5218 right_part_masked
= 1;
5220 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5222 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5224 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5225 pot_right_ptr
->plain_len
= mask_plain_len
;
5228 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5232 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5234 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5236 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5238 // do output the line
5240 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5242 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5244 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5245 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5248 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
)
5252 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5254 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5256 if (pot_ptr
== NULL
)
5260 input_buf
[input_len
] = 0;
5262 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5266 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
)
5272 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5274 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5278 pot_t pot_right_key
;
5280 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5282 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5284 uint weak_hash_found
= 0;
5286 if (pot_right_ptr
== NULL
)
5288 // special case, if "weak hash"
5290 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5292 weak_hash_found
= 1;
5294 // we just need that pot_right_ptr is not a NULL pointer
5296 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5300 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5302 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5307 // ... at least one part was not cracked
5311 input_buf
[input_len
] = 0;
5313 // only show the hash part which is still not cracked
5315 uint user_len
= input_len
- 32;
5317 char *hash_output
= (char *) mymalloc (33);
5319 memcpy (hash_output
, input_buf
, input_len
);
5321 if (pot_left_ptr
!= NULL
)
5323 // only show right part (because left part was already found)
5325 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5327 hash_output
[user_len
+ 16] = 0;
5330 if (pot_right_ptr
!= NULL
)
5332 // only show left part (because right part was already found)
5334 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5336 hash_output
[user_len
+ 16] = 0;
5339 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5341 myfree (hash_output
);
5343 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5346 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5348 uint opencl_platforms_filter
= 0;
5350 if (opencl_platforms
)
5352 char *platforms
= strdup (opencl_platforms
);
5354 char *next
= strtok (platforms
, ",");
5358 int platform
= atoi (next
);
5360 if (platform
< 1 || platform
> 32)
5362 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5367 opencl_platforms_filter
|= 1 << (platform
- 1);
5369 } while ((next
= strtok (NULL
, ",")) != NULL
);
5375 opencl_platforms_filter
= -1;
5378 return opencl_platforms_filter
;
5381 u32
setup_devices_filter (char *opencl_devices
)
5383 u32 devices_filter
= 0;
5387 char *devices
= strdup (opencl_devices
);
5389 char *next
= strtok (devices
, ",");
5393 int device_id
= atoi (next
);
5395 if (device_id
< 1 || device_id
> 32)
5397 log_error ("ERROR: invalid device_id %u specified", device_id
);
5402 devices_filter
|= 1 << (device_id
- 1);
5404 } while ((next
= strtok (NULL
, ",")) != NULL
);
5410 devices_filter
= -1;
5413 return devices_filter
;
5416 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5418 cl_device_type device_types_filter
= 0;
5420 if (opencl_device_types
)
5422 char *device_types
= strdup (opencl_device_types
);
5424 char *next
= strtok (device_types
, ",");
5428 int device_type
= atoi (next
);
5430 if (device_type
< 1 || device_type
> 3)
5432 log_error ("ERROR: invalid device_type %u specified", device_type
);
5437 device_types_filter
|= 1 << device_type
;
5439 } while ((next
= strtok (NULL
, ",")) != NULL
);
5441 free (device_types
);
5445 // Do not use CPU by default, this often reduces GPU performance because
5446 // the CPU is too busy to handle GPU synchronization
5448 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5451 return device_types_filter
;
5454 u32
get_random_num (const u32 min
, const u32 max
)
5456 if (min
== max
) return (min
);
5458 return ((rand () % (max
- min
)) + min
);
5461 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5463 u32 quotient
= dividend
/ divisor
;
5465 if (dividend
% divisor
) quotient
++;
5470 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5472 u64 quotient
= dividend
/ divisor
;
5474 if (dividend
% divisor
) quotient
++;
5479 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5481 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5482 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5484 if (tm
->tm_year
- 70)
5486 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5487 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5489 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5491 else if (tm
->tm_yday
)
5493 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5494 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5496 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5498 else if (tm
->tm_hour
)
5500 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5501 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5503 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5505 else if (tm
->tm_min
)
5507 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5508 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5510 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5514 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5516 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5520 void format_speed_display (float val
, char *buf
, size_t len
)
5531 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5542 /* generate output */
5546 snprintf (buf
, len
- 1, "%.0f ", val
);
5550 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5554 void lowercase (u8
*buf
, int len
)
5556 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5559 void uppercase (u8
*buf
, int len
)
5561 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5564 int fgetl (FILE *fp
, char *line_buf
)
5570 const int c
= fgetc (fp
);
5572 if (c
== EOF
) break;
5574 line_buf
[line_len
] = (char) c
;
5578 if (line_len
== HCBUFSIZ
) line_len
--;
5580 if (c
== '\n') break;
5583 if (line_len
== 0) return 0;
5585 if (line_buf
[line_len
- 1] == '\n')
5589 line_buf
[line_len
] = 0;
5592 if (line_len
== 0) return 0;
5594 if (line_buf
[line_len
- 1] == '\r')
5598 line_buf
[line_len
] = 0;
5604 int in_superchop (char *buf
)
5606 int len
= strlen (buf
);
5610 if (buf
[len
- 1] == '\n')
5617 if (buf
[len
- 1] == '\r')
5632 char **scan_directory (const char *path
)
5634 char *tmp_path
= mystrdup (path
);
5636 size_t tmp_path_len
= strlen (tmp_path
);
5638 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5640 tmp_path
[tmp_path_len
- 1] = 0;
5642 tmp_path_len
= strlen (tmp_path
);
5645 char **files
= NULL
;
5651 if ((d
= opendir (tmp_path
)) != NULL
)
5657 memset (&e
, 0, sizeof (e
));
5658 struct dirent
*de
= NULL
;
5660 if (readdir_r (d
, &e
, &de
) != 0)
5662 log_error ("ERROR: readdir_r() failed");
5667 if (de
== NULL
) break;
5671 while ((de
= readdir (d
)) != NULL
)
5674 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5676 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5678 char *path_file
= (char *) mymalloc (path_size
+ 1);
5680 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5682 path_file
[path_size
] = 0;
5686 if ((d_test
= opendir (path_file
)) != NULL
)
5694 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5698 files
[num_files
- 1] = path_file
;
5704 else if (errno
== ENOTDIR
)
5706 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5710 files
[num_files
- 1] = mystrdup (path
);
5713 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5717 files
[num_files
- 1] = NULL
;
5724 int count_dictionaries (char **dictionary_files
)
5726 if (dictionary_files
== NULL
) return 0;
5730 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5738 char *stroptitype (const uint opti_type
)
5742 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5743 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5744 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5745 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5746 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5747 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5748 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5749 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5750 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5751 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5752 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5753 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5754 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5755 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5756 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5757 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5758 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5759 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5760 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5766 char *strparser (const uint parser_status
)
5768 switch (parser_status
)
5770 case PARSER_OK
: return ((char *) PA_000
); break;
5771 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5772 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5773 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5774 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5775 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5776 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5777 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5778 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5779 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5780 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5781 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5782 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5783 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5784 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5785 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5786 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5789 return ((char *) PA_255
);
5792 char *strhashtype (const uint hash_mode
)
5796 case 0: return ((char *) HT_00000
); break;
5797 case 10: return ((char *) HT_00010
); break;
5798 case 11: return ((char *) HT_00011
); break;
5799 case 12: return ((char *) HT_00012
); break;
5800 case 20: return ((char *) HT_00020
); break;
5801 case 21: return ((char *) HT_00021
); break;
5802 case 22: return ((char *) HT_00022
); break;
5803 case 23: return ((char *) HT_00023
); break;
5804 case 30: return ((char *) HT_00030
); break;
5805 case 40: return ((char *) HT_00040
); break;
5806 case 50: return ((char *) HT_00050
); break;
5807 case 60: return ((char *) HT_00060
); break;
5808 case 100: return ((char *) HT_00100
); break;
5809 case 101: return ((char *) HT_00101
); break;
5810 case 110: return ((char *) HT_00110
); break;
5811 case 111: return ((char *) HT_00111
); break;
5812 case 112: return ((char *) HT_00112
); break;
5813 case 120: return ((char *) HT_00120
); break;
5814 case 121: return ((char *) HT_00121
); break;
5815 case 122: return ((char *) HT_00122
); break;
5816 case 124: return ((char *) HT_00124
); break;
5817 case 125: return ((char *) HT_00125
); break;
5818 case 130: return ((char *) HT_00130
); break;
5819 case 131: return ((char *) HT_00131
); break;
5820 case 132: return ((char *) HT_00132
); break;
5821 case 133: return ((char *) HT_00133
); break;
5822 case 140: return ((char *) HT_00140
); break;
5823 case 141: return ((char *) HT_00141
); break;
5824 case 150: return ((char *) HT_00150
); break;
5825 case 160: return ((char *) HT_00160
); break;
5826 case 190: return ((char *) HT_00190
); break;
5827 case 200: return ((char *) HT_00200
); break;
5828 case 300: return ((char *) HT_00300
); break;
5829 case 400: return ((char *) HT_00400
); break;
5830 case 500: return ((char *) HT_00500
); break;
5831 case 501: return ((char *) HT_00501
); break;
5832 case 900: return ((char *) HT_00900
); break;
5833 case 910: return ((char *) HT_00910
); break;
5834 case 1000: return ((char *) HT_01000
); break;
5835 case 1100: return ((char *) HT_01100
); break;
5836 case 1400: return ((char *) HT_01400
); break;
5837 case 1410: return ((char *) HT_01410
); break;
5838 case 1420: return ((char *) HT_01420
); break;
5839 case 1421: return ((char *) HT_01421
); break;
5840 case 1430: return ((char *) HT_01430
); break;
5841 case 1440: return ((char *) HT_01440
); break;
5842 case 1441: return ((char *) HT_01441
); break;
5843 case 1450: return ((char *) HT_01450
); break;
5844 case 1460: return ((char *) HT_01460
); break;
5845 case 1500: return ((char *) HT_01500
); break;
5846 case 1600: return ((char *) HT_01600
); break;
5847 case 1700: return ((char *) HT_01700
); break;
5848 case 1710: return ((char *) HT_01710
); break;
5849 case 1711: return ((char *) HT_01711
); break;
5850 case 1720: return ((char *) HT_01720
); break;
5851 case 1722: return ((char *) HT_01722
); break;
5852 case 1730: return ((char *) HT_01730
); break;
5853 case 1731: return ((char *) HT_01731
); break;
5854 case 1740: return ((char *) HT_01740
); break;
5855 case 1750: return ((char *) HT_01750
); break;
5856 case 1760: return ((char *) HT_01760
); break;
5857 case 1800: return ((char *) HT_01800
); break;
5858 case 2100: return ((char *) HT_02100
); break;
5859 case 2400: return ((char *) HT_02400
); break;
5860 case 2410: return ((char *) HT_02410
); break;
5861 case 2500: return ((char *) HT_02500
); break;
5862 case 2600: return ((char *) HT_02600
); break;
5863 case 2611: return ((char *) HT_02611
); break;
5864 case 2612: return ((char *) HT_02612
); break;
5865 case 2711: return ((char *) HT_02711
); break;
5866 case 2811: return ((char *) HT_02811
); break;
5867 case 3000: return ((char *) HT_03000
); break;
5868 case 3100: return ((char *) HT_03100
); break;
5869 case 3200: return ((char *) HT_03200
); break;
5870 case 3710: return ((char *) HT_03710
); break;
5871 case 3711: return ((char *) HT_03711
); break;
5872 case 3800: return ((char *) HT_03800
); break;
5873 case 4300: return ((char *) HT_04300
); break;
5874 case 4400: return ((char *) HT_04400
); break;
5875 case 4500: return ((char *) HT_04500
); break;
5876 case 4700: return ((char *) HT_04700
); break;
5877 case 4800: return ((char *) HT_04800
); break;
5878 case 4900: return ((char *) HT_04900
); break;
5879 case 5000: return ((char *) HT_05000
); break;
5880 case 5100: return ((char *) HT_05100
); break;
5881 case 5200: return ((char *) HT_05200
); break;
5882 case 5300: return ((char *) HT_05300
); break;
5883 case 5400: return ((char *) HT_05400
); break;
5884 case 5500: return ((char *) HT_05500
); break;
5885 case 5600: return ((char *) HT_05600
); break;
5886 case 5700: return ((char *) HT_05700
); break;
5887 case 5800: return ((char *) HT_05800
); break;
5888 case 6000: return ((char *) HT_06000
); break;
5889 case 6100: return ((char *) HT_06100
); break;
5890 case 6211: return ((char *) HT_06211
); break;
5891 case 6212: return ((char *) HT_06212
); break;
5892 case 6213: return ((char *) HT_06213
); break;
5893 case 6221: return ((char *) HT_06221
); break;
5894 case 6222: return ((char *) HT_06222
); break;
5895 case 6223: return ((char *) HT_06223
); break;
5896 case 6231: return ((char *) HT_06231
); break;
5897 case 6232: return ((char *) HT_06232
); break;
5898 case 6233: return ((char *) HT_06233
); break;
5899 case 6241: return ((char *) HT_06241
); break;
5900 case 6242: return ((char *) HT_06242
); break;
5901 case 6243: return ((char *) HT_06243
); break;
5902 case 6300: return ((char *) HT_06300
); break;
5903 case 6400: return ((char *) HT_06400
); break;
5904 case 6500: return ((char *) HT_06500
); break;
5905 case 6600: return ((char *) HT_06600
); break;
5906 case 6700: return ((char *) HT_06700
); break;
5907 case 6800: return ((char *) HT_06800
); break;
5908 case 6900: return ((char *) HT_06900
); break;
5909 case 7100: return ((char *) HT_07100
); break;
5910 case 7200: return ((char *) HT_07200
); break;
5911 case 7300: return ((char *) HT_07300
); break;
5912 case 7400: return ((char *) HT_07400
); break;
5913 case 7500: return ((char *) HT_07500
); break;
5914 case 7600: return ((char *) HT_07600
); break;
5915 case 7700: return ((char *) HT_07700
); break;
5916 case 7800: return ((char *) HT_07800
); break;
5917 case 7900: return ((char *) HT_07900
); break;
5918 case 8000: return ((char *) HT_08000
); break;
5919 case 8100: return ((char *) HT_08100
); break;
5920 case 8200: return ((char *) HT_08200
); break;
5921 case 8300: return ((char *) HT_08300
); break;
5922 case 8400: return ((char *) HT_08400
); break;
5923 case 8500: return ((char *) HT_08500
); break;
5924 case 8600: return ((char *) HT_08600
); break;
5925 case 8700: return ((char *) HT_08700
); break;
5926 case 8800: return ((char *) HT_08800
); break;
5927 case 8900: return ((char *) HT_08900
); break;
5928 case 9000: return ((char *) HT_09000
); break;
5929 case 9100: return ((char *) HT_09100
); break;
5930 case 9200: return ((char *) HT_09200
); break;
5931 case 9300: return ((char *) HT_09300
); break;
5932 case 9400: return ((char *) HT_09400
); break;
5933 case 9500: return ((char *) HT_09500
); break;
5934 case 9600: return ((char *) HT_09600
); break;
5935 case 9700: return ((char *) HT_09700
); break;
5936 case 9710: return ((char *) HT_09710
); break;
5937 case 9720: return ((char *) HT_09720
); break;
5938 case 9800: return ((char *) HT_09800
); break;
5939 case 9810: return ((char *) HT_09810
); break;
5940 case 9820: return ((char *) HT_09820
); break;
5941 case 9900: return ((char *) HT_09900
); break;
5942 case 10000: return ((char *) HT_10000
); break;
5943 case 10100: return ((char *) HT_10100
); break;
5944 case 10200: return ((char *) HT_10200
); break;
5945 case 10300: return ((char *) HT_10300
); break;
5946 case 10400: return ((char *) HT_10400
); break;
5947 case 10410: return ((char *) HT_10410
); break;
5948 case 10420: return ((char *) HT_10420
); break;
5949 case 10500: return ((char *) HT_10500
); break;
5950 case 10600: return ((char *) HT_10600
); break;
5951 case 10700: return ((char *) HT_10700
); break;
5952 case 10800: return ((char *) HT_10800
); break;
5953 case 10900: return ((char *) HT_10900
); break;
5954 case 11000: return ((char *) HT_11000
); break;
5955 case 11100: return ((char *) HT_11100
); break;
5956 case 11200: return ((char *) HT_11200
); break;
5957 case 11300: return ((char *) HT_11300
); break;
5958 case 11400: return ((char *) HT_11400
); break;
5959 case 11500: return ((char *) HT_11500
); break;
5960 case 11600: return ((char *) HT_11600
); break;
5961 case 11700: return ((char *) HT_11700
); break;
5962 case 11800: return ((char *) HT_11800
); break;
5963 case 11900: return ((char *) HT_11900
); break;
5964 case 12000: return ((char *) HT_12000
); break;
5965 case 12100: return ((char *) HT_12100
); break;
5966 case 12200: return ((char *) HT_12200
); break;
5967 case 12300: return ((char *) HT_12300
); break;
5968 case 12400: return ((char *) HT_12400
); break;
5969 case 12500: return ((char *) HT_12500
); break;
5970 case 12600: return ((char *) HT_12600
); break;
5971 case 12700: return ((char *) HT_12700
); break;
5972 case 12800: return ((char *) HT_12800
); break;
5973 case 12900: return ((char *) HT_12900
); break;
5974 case 13000: return ((char *) HT_13000
); break;
5975 case 13100: return ((char *) HT_13100
); break;
5976 case 13200: return ((char *) HT_13200
); break;
5977 case 13300: return ((char *) HT_13300
); break;
5978 case 13400: return ((char *) HT_13400
); break;
5979 case 13500: return ((char *) HT_13500
); break;
5980 case 13600: return ((char *) HT_13600
); break;
5981 case 13711: return ((char *) HT_13711
); break;
5982 case 13712: return ((char *) HT_13712
); break;
5983 case 13713: return ((char *) HT_13713
); break;
5984 case 13721: return ((char *) HT_13721
); break;
5985 case 13722: return ((char *) HT_13722
); break;
5986 case 13723: return ((char *) HT_13723
); break;
5987 case 13731: return ((char *) HT_13731
); break;
5988 case 13732: return ((char *) HT_13732
); break;
5989 case 13733: return ((char *) HT_13733
); break;
5990 case 13741: return ((char *) HT_13741
); break;
5991 case 13742: return ((char *) HT_13742
); break;
5992 case 13743: return ((char *) HT_13743
); break;
5993 case 13751: return ((char *) HT_13751
); break;
5994 case 13752: return ((char *) HT_13752
); break;
5995 case 13753: return ((char *) HT_13753
); break;
5996 case 13761: return ((char *) HT_13761
); break;
5997 case 13762: return ((char *) HT_13762
); break;
5998 case 13763: return ((char *) HT_13763
); break;
6001 return ((char *) "Unknown");
6004 char *strstatus (const uint devices_status
)
6006 switch (devices_status
)
6008 case STATUS_INIT
: return ((char *) ST_0000
); break;
6009 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6010 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6011 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6012 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6013 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6014 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6015 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6016 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6017 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6018 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6021 return ((char *) "Unknown");
6024 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6026 uint hash_type
= data
.hash_type
;
6027 uint hash_mode
= data
.hash_mode
;
6028 uint salt_type
= data
.salt_type
;
6029 uint opts_type
= data
.opts_type
;
6030 uint opti_type
= data
.opti_type
;
6031 uint dgst_size
= data
.dgst_size
;
6033 char *hashfile
= data
.hashfile
;
6037 uint digest_buf
[64] = { 0 };
6039 u64
*digest_buf64
= (u64
*) digest_buf
;
6041 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6043 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6045 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6051 case HASH_TYPE_DESCRYPT
:
6052 FP (digest_buf
[1], digest_buf
[0], tt
);
6055 case HASH_TYPE_DESRACF
:
6056 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6057 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6059 FP (digest_buf
[1], digest_buf
[0], tt
);
6063 FP (digest_buf
[1], digest_buf
[0], tt
);
6066 case HASH_TYPE_NETNTLM
:
6067 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6068 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6069 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6070 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6072 FP (digest_buf
[1], digest_buf
[0], tt
);
6073 FP (digest_buf
[3], digest_buf
[2], tt
);
6076 case HASH_TYPE_BSDICRYPT
:
6077 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6078 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6080 FP (digest_buf
[1], digest_buf
[0], tt
);
6085 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6090 digest_buf
[0] += MD4M_A
;
6091 digest_buf
[1] += MD4M_B
;
6092 digest_buf
[2] += MD4M_C
;
6093 digest_buf
[3] += MD4M_D
;
6097 digest_buf
[0] += MD5M_A
;
6098 digest_buf
[1] += MD5M_B
;
6099 digest_buf
[2] += MD5M_C
;
6100 digest_buf
[3] += MD5M_D
;
6103 case HASH_TYPE_SHA1
:
6104 digest_buf
[0] += SHA1M_A
;
6105 digest_buf
[1] += SHA1M_B
;
6106 digest_buf
[2] += SHA1M_C
;
6107 digest_buf
[3] += SHA1M_D
;
6108 digest_buf
[4] += SHA1M_E
;
6111 case HASH_TYPE_SHA256
:
6112 digest_buf
[0] += SHA256M_A
;
6113 digest_buf
[1] += SHA256M_B
;
6114 digest_buf
[2] += SHA256M_C
;
6115 digest_buf
[3] += SHA256M_D
;
6116 digest_buf
[4] += SHA256M_E
;
6117 digest_buf
[5] += SHA256M_F
;
6118 digest_buf
[6] += SHA256M_G
;
6119 digest_buf
[7] += SHA256M_H
;
6122 case HASH_TYPE_SHA384
:
6123 digest_buf64
[0] += SHA384M_A
;
6124 digest_buf64
[1] += SHA384M_B
;
6125 digest_buf64
[2] += SHA384M_C
;
6126 digest_buf64
[3] += SHA384M_D
;
6127 digest_buf64
[4] += SHA384M_E
;
6128 digest_buf64
[5] += SHA384M_F
;
6129 digest_buf64
[6] += 0;
6130 digest_buf64
[7] += 0;
6133 case HASH_TYPE_SHA512
:
6134 digest_buf64
[0] += SHA512M_A
;
6135 digest_buf64
[1] += SHA512M_B
;
6136 digest_buf64
[2] += SHA512M_C
;
6137 digest_buf64
[3] += SHA512M_D
;
6138 digest_buf64
[4] += SHA512M_E
;
6139 digest_buf64
[5] += SHA512M_F
;
6140 digest_buf64
[6] += SHA512M_G
;
6141 digest_buf64
[7] += SHA512M_H
;
6146 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6148 if (dgst_size
== DGST_SIZE_4_2
)
6150 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6152 else if (dgst_size
== DGST_SIZE_4_4
)
6154 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6156 else if (dgst_size
== DGST_SIZE_4_5
)
6158 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6160 else if (dgst_size
== DGST_SIZE_4_6
)
6162 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6164 else if (dgst_size
== DGST_SIZE_4_8
)
6166 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6168 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6170 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6172 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6174 else if (hash_type
== HASH_TYPE_SHA384
)
6176 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6178 else if (hash_type
== HASH_TYPE_SHA512
)
6180 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6182 else if (hash_type
== HASH_TYPE_GOST
)
6184 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6187 else if (dgst_size
== DGST_SIZE_4_64
)
6189 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6191 else if (dgst_size
== DGST_SIZE_8_25
)
6193 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6197 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6198 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6199 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6205 memset (&salt
, 0, sizeof (salt_t
));
6207 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6209 char *ptr
= (char *) salt
.salt_buf
;
6211 uint len
= salt
.salt_len
;
6213 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6219 case HASH_TYPE_NETNTLM
:
6221 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6222 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6224 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6230 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6232 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6240 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6242 uint max
= salt
.salt_len
/ 4;
6246 for (uint i
= 0; i
< max
; i
++)
6248 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6252 if (opts_type
& OPTS_TYPE_ST_HEX
)
6254 char tmp
[64] = { 0 };
6256 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6258 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6263 memcpy (ptr
, tmp
, len
);
6266 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6268 memset (ptr
+ len
, 0, memset_size
);
6270 salt
.salt_len
= len
;
6274 // some modes require special encoding
6277 uint out_buf_plain
[256] = { 0 };
6278 uint out_buf_salt
[256] = { 0 };
6280 char tmp_buf
[1024] = { 0 };
6282 char *ptr_plain
= (char *) out_buf_plain
;
6283 char *ptr_salt
= (char *) out_buf_salt
;
6285 if (hash_mode
== 22)
6287 char username
[30] = { 0 };
6289 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6291 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6293 u16
*ptr
= (u16
*) digest_buf
;
6295 tmp_buf
[ 0] = sig
[0];
6296 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6297 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6298 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6299 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6300 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6301 tmp_buf
[ 6] = sig
[1];
6302 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6303 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6304 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6305 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6306 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6307 tmp_buf
[12] = sig
[2];
6308 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6309 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6310 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6311 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6312 tmp_buf
[17] = sig
[3];
6313 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6314 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6315 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6316 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6317 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6318 tmp_buf
[23] = sig
[4];
6319 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6320 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6321 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6322 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6323 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6324 tmp_buf
[29] = sig
[5];
6326 snprintf (out_buf
, len
-1, "%s:%s",
6330 else if (hash_mode
== 23)
6332 // do not show the skyper part in output
6334 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6336 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6338 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6345 else if (hash_mode
== 101)
6347 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6349 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6350 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6351 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6352 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6353 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6355 memcpy (tmp_buf
, digest_buf
, 20);
6357 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6359 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6361 else if (hash_mode
== 111)
6363 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6365 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6366 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6367 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6368 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6369 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6371 memcpy (tmp_buf
, digest_buf
, 20);
6372 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6374 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6376 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6378 else if ((hash_mode
== 122) || (hash_mode
== 125))
6380 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6381 (char *) salt
.salt_buf
,
6388 else if (hash_mode
== 124)
6390 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6391 (char *) salt
.salt_buf
,
6398 else if (hash_mode
== 131)
6400 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6401 (char *) salt
.salt_buf
,
6409 else if (hash_mode
== 132)
6411 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6412 (char *) salt
.salt_buf
,
6419 else if (hash_mode
== 133)
6421 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6423 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6424 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6425 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6426 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6427 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6429 memcpy (tmp_buf
, digest_buf
, 20);
6431 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6433 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6435 else if (hash_mode
== 141)
6437 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6439 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6441 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6443 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6445 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6446 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6447 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6448 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6449 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6451 memcpy (tmp_buf
, digest_buf
, 20);
6453 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6457 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6459 else if (hash_mode
== 400)
6461 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6463 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6464 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6465 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6466 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6468 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6470 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6472 else if (hash_mode
== 500)
6474 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6476 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6477 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6478 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6479 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6481 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6483 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6485 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6489 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6492 else if (hash_mode
== 501)
6494 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6496 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6497 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6499 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6501 else if (hash_mode
== 1421)
6503 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6505 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6521 else if (hash_mode
== 1441)
6523 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6525 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6527 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6529 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6531 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6532 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6533 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6534 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6535 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6536 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6537 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6538 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6540 memcpy (tmp_buf
, digest_buf
, 32);
6542 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6546 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6548 else if (hash_mode
== 1500)
6550 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6551 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6552 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6553 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6554 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6556 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6558 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6560 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6561 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6563 memcpy (tmp_buf
, digest_buf
, 8);
6565 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6567 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6571 else if (hash_mode
== 1600)
6573 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6575 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6576 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6577 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6578 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6580 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6582 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6584 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6588 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6591 else if (hash_mode
== 1711)
6593 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6595 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6596 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6597 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6598 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6599 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6600 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6601 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6602 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6604 memcpy (tmp_buf
, digest_buf
, 64);
6605 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6607 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6609 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6611 else if (hash_mode
== 1722)
6613 uint
*ptr
= digest_buf
;
6615 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6616 (unsigned char *) salt
.salt_buf
,
6626 else if (hash_mode
== 1731)
6628 uint
*ptr
= digest_buf
;
6630 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6631 (unsigned char *) salt
.salt_buf
,
6641 else if (hash_mode
== 1800)
6645 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6646 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6647 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6648 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6649 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6650 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6651 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6652 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6654 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6656 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6658 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6662 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6665 else if (hash_mode
== 2100)
6669 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6671 salt
.salt_iter
+ 1);
6673 uint signature_len
= strlen (out_buf
);
6675 pos
+= signature_len
;
6676 len
-= signature_len
;
6678 char *salt_ptr
= (char *) salt
.salt_buf
;
6680 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6682 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6683 byte_swap_32 (digest_buf
[0]),
6684 byte_swap_32 (digest_buf
[1]),
6685 byte_swap_32 (digest_buf
[2]),
6686 byte_swap_32 (digest_buf
[3]));
6688 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6690 memcpy (tmp_buf
, digest_buf
, 16);
6692 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6694 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6695 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6696 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6697 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6699 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6700 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6701 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6702 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6704 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6705 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6706 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6707 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6709 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6710 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6711 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6712 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6714 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6715 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6716 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6717 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6721 else if (hash_mode
== 2500)
6723 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6725 wpa_t
*wpa
= &wpas
[salt_pos
];
6727 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6728 (char *) salt
.salt_buf
,
6742 else if (hash_mode
== 4400)
6744 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6745 byte_swap_32 (digest_buf
[0]),
6746 byte_swap_32 (digest_buf
[1]),
6747 byte_swap_32 (digest_buf
[2]),
6748 byte_swap_32 (digest_buf
[3]));
6750 else if (hash_mode
== 4700)
6752 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6753 byte_swap_32 (digest_buf
[0]),
6754 byte_swap_32 (digest_buf
[1]),
6755 byte_swap_32 (digest_buf
[2]),
6756 byte_swap_32 (digest_buf
[3]),
6757 byte_swap_32 (digest_buf
[4]));
6759 else if (hash_mode
== 4800)
6761 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6763 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6768 byte_swap_32 (salt
.salt_buf
[0]),
6769 byte_swap_32 (salt
.salt_buf
[1]),
6770 byte_swap_32 (salt
.salt_buf
[2]),
6771 byte_swap_32 (salt
.salt_buf
[3]),
6774 else if (hash_mode
== 4900)
6776 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6777 byte_swap_32 (digest_buf
[0]),
6778 byte_swap_32 (digest_buf
[1]),
6779 byte_swap_32 (digest_buf
[2]),
6780 byte_swap_32 (digest_buf
[3]),
6781 byte_swap_32 (digest_buf
[4]));
6783 else if (hash_mode
== 5100)
6785 snprintf (out_buf
, len
-1, "%08x%08x",
6789 else if (hash_mode
== 5200)
6791 snprintf (out_buf
, len
-1, "%s", hashfile
);
6793 else if (hash_mode
== 5300)
6795 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6797 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6799 int buf_len
= len
-1;
6803 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6805 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6807 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6809 snprintf (out_buf
, buf_len
, ":");
6815 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6823 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6825 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6827 if ((i
== 0) || (i
== 5))
6829 snprintf (out_buf
, buf_len
, ":");
6835 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6843 for (uint i
= 0; i
< 4; i
++)
6847 snprintf (out_buf
, buf_len
, ":");
6853 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6859 else if (hash_mode
== 5400)
6861 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6863 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6865 int buf_len
= len
-1;
6869 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6871 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6873 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6875 snprintf (out_buf
, buf_len
, ":");
6881 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6889 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6891 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6893 if ((i
== 0) || (i
== 5))
6895 snprintf (out_buf
, buf_len
, ":");
6901 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6909 for (uint i
= 0; i
< 5; i
++)
6913 snprintf (out_buf
, buf_len
, ":");
6919 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6925 else if (hash_mode
== 5500)
6927 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6929 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6931 char user_buf
[64] = { 0 };
6932 char domain_buf
[64] = { 0 };
6933 char srvchall_buf
[1024] = { 0 };
6934 char clichall_buf
[1024] = { 0 };
6936 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6938 char *ptr
= (char *) netntlm
->userdomain_buf
;
6940 user_buf
[i
] = ptr
[j
];
6943 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6945 char *ptr
= (char *) netntlm
->userdomain_buf
;
6947 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6950 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6952 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6954 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6957 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6959 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6961 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6964 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6972 byte_swap_32 (salt
.salt_buf_pc
[0]),
6973 byte_swap_32 (salt
.salt_buf_pc
[1]),
6976 else if (hash_mode
== 5600)
6978 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6980 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6982 char user_buf
[64] = { 0 };
6983 char domain_buf
[64] = { 0 };
6984 char srvchall_buf
[1024] = { 0 };
6985 char clichall_buf
[1024] = { 0 };
6987 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6989 char *ptr
= (char *) netntlm
->userdomain_buf
;
6991 user_buf
[i
] = ptr
[j
];
6994 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6996 char *ptr
= (char *) netntlm
->userdomain_buf
;
6998 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7001 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7003 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7005 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7008 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7010 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7012 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7015 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7025 else if (hash_mode
== 5700)
7027 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7029 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7030 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7031 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7032 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7033 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7034 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7035 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7036 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7038 memcpy (tmp_buf
, digest_buf
, 32);
7040 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7044 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7046 else if (hash_mode
== 5800)
7048 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7049 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7050 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7051 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7052 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7054 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7061 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7063 snprintf (out_buf
, len
-1, "%s", hashfile
);
7065 else if (hash_mode
== 6300)
7067 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7074 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7076 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7078 else if (hash_mode
== 6400)
7080 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7082 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7084 else if (hash_mode
== 6500)
7086 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7088 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7090 else if (hash_mode
== 6600)
7092 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7094 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7096 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7097 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7099 uint buf_len
= len
- 1;
7101 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7104 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7106 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7111 else if (hash_mode
== 6700)
7113 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7115 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7117 else if (hash_mode
== 6800)
7119 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7121 else if (hash_mode
== 7100)
7123 uint
*ptr
= digest_buf
;
7125 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7127 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7129 uint esalt
[8] = { 0 };
7131 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7132 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7133 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7134 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7135 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7136 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7137 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7138 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7140 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",
7141 SIGNATURE_SHA512OSX
,
7143 esalt
[ 0], esalt
[ 1],
7144 esalt
[ 2], esalt
[ 3],
7145 esalt
[ 4], esalt
[ 5],
7146 esalt
[ 6], esalt
[ 7],
7154 ptr
[15], ptr
[14]);
7156 else if (hash_mode
== 7200)
7158 uint
*ptr
= digest_buf
;
7160 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7162 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7166 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7168 len_used
= strlen (out_buf
);
7170 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7172 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7174 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7177 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",
7185 ptr
[15], ptr
[14]);
7187 else if (hash_mode
== 7300)
7189 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7191 rakp_t
*rakp
= &rakps
[salt_pos
];
7193 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7195 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7198 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7205 else if (hash_mode
== 7400)
7207 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7209 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7210 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7211 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7212 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7213 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7214 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7215 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7216 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7218 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7220 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7222 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7226 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7229 else if (hash_mode
== 7500)
7231 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7233 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7235 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7236 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7238 char data
[128] = { 0 };
7240 char *ptr_data
= data
;
7242 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7244 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7247 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7249 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7254 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7256 (char *) krb5pa
->user
,
7257 (char *) krb5pa
->realm
,
7258 (char *) krb5pa
->salt
,
7261 else if (hash_mode
== 7700)
7263 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7264 (char *) salt
.salt_buf
,
7268 else if (hash_mode
== 7800)
7270 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7271 (char *) salt
.salt_buf
,
7278 else if (hash_mode
== 7900)
7280 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7284 char *tmp
= (char *) salt
.salt_buf_pc
;
7286 ptr_plain
[42] = tmp
[0];
7292 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7294 else if (hash_mode
== 8000)
7296 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7297 (unsigned char *) salt
.salt_buf
,
7307 else if (hash_mode
== 8100)
7309 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7310 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7312 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7313 (unsigned char *) salt
.salt_buf
,
7320 else if (hash_mode
== 8200)
7322 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7324 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7326 char data_buf
[4096] = { 0 };
7328 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7330 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7333 data_buf
[cloudkey
->data_len
* 2] = 0;
7335 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7336 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7337 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7338 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7339 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7340 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7341 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7342 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7344 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7345 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7346 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7347 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7349 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7365 else if (hash_mode
== 8300)
7367 char digest_buf_c
[34] = { 0 };
7369 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7370 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7371 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7372 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7373 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7375 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7377 digest_buf_c
[32] = 0;
7381 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7383 char domain_buf_c
[33] = { 0 };
7385 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7387 for (uint i
= 0; i
< salt_pc_len
; i
++)
7389 const char next
= domain_buf_c
[i
];
7391 domain_buf_c
[i
] = '.';
7396 domain_buf_c
[salt_pc_len
] = 0;
7400 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7402 else if (hash_mode
== 8500)
7404 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7406 else if (hash_mode
== 2612)
7408 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7410 (char *) salt
.salt_buf
,
7416 else if (hash_mode
== 3711)
7418 char *salt_ptr
= (char *) salt
.salt_buf
;
7420 salt_ptr
[salt
.salt_len
- 1] = 0;
7422 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7423 SIGNATURE_MEDIAWIKI_B
,
7430 else if (hash_mode
== 8800)
7432 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7434 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7436 char tmp
[3073] = { 0 };
7438 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7440 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7445 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7446 SIGNATURE_ANDROIDFDE
,
7447 byte_swap_32 (salt
.salt_buf
[0]),
7448 byte_swap_32 (salt
.salt_buf
[1]),
7449 byte_swap_32 (salt
.salt_buf
[2]),
7450 byte_swap_32 (salt
.salt_buf
[3]),
7451 byte_swap_32 (digest_buf
[0]),
7452 byte_swap_32 (digest_buf
[1]),
7453 byte_swap_32 (digest_buf
[2]),
7454 byte_swap_32 (digest_buf
[3]),
7457 else if (hash_mode
== 8900)
7459 uint N
= salt
.scrypt_N
;
7460 uint r
= salt
.scrypt_r
;
7461 uint p
= salt
.scrypt_p
;
7463 char base64_salt
[32] = { 0 };
7465 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7467 memset (tmp_buf
, 0, 46);
7469 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7470 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7471 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7472 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7473 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7474 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7475 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7476 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7477 digest_buf
[8] = 0; // needed for base64_encode ()
7479 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7481 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7489 else if (hash_mode
== 9000)
7491 snprintf (out_buf
, len
-1, "%s", hashfile
);
7493 else if (hash_mode
== 9200)
7497 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7499 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7501 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
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 char tmp_buf
[64] = { 0 };
7517 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7518 tmp_buf
[43] = 0; // cut it here
7522 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7524 else if (hash_mode
== 9300)
7526 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7527 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7528 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7529 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7530 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7531 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7532 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7533 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7534 digest_buf
[8] = 0; // needed for base64_encode ()
7536 char tmp_buf
[64] = { 0 };
7538 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7539 tmp_buf
[43] = 0; // cut it here
7541 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7543 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7545 else if (hash_mode
== 9400)
7547 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7549 office2007_t
*office2007
= &office2007s
[salt_pos
];
7551 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7552 SIGNATURE_OFFICE2007
,
7555 office2007
->keySize
,
7561 office2007
->encryptedVerifier
[0],
7562 office2007
->encryptedVerifier
[1],
7563 office2007
->encryptedVerifier
[2],
7564 office2007
->encryptedVerifier
[3],
7565 office2007
->encryptedVerifierHash
[0],
7566 office2007
->encryptedVerifierHash
[1],
7567 office2007
->encryptedVerifierHash
[2],
7568 office2007
->encryptedVerifierHash
[3],
7569 office2007
->encryptedVerifierHash
[4]);
7571 else if (hash_mode
== 9500)
7573 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7575 office2010_t
*office2010
= &office2010s
[salt_pos
];
7577 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,
7583 office2010
->encryptedVerifier
[0],
7584 office2010
->encryptedVerifier
[1],
7585 office2010
->encryptedVerifier
[2],
7586 office2010
->encryptedVerifier
[3],
7587 office2010
->encryptedVerifierHash
[0],
7588 office2010
->encryptedVerifierHash
[1],
7589 office2010
->encryptedVerifierHash
[2],
7590 office2010
->encryptedVerifierHash
[3],
7591 office2010
->encryptedVerifierHash
[4],
7592 office2010
->encryptedVerifierHash
[5],
7593 office2010
->encryptedVerifierHash
[6],
7594 office2010
->encryptedVerifierHash
[7]);
7596 else if (hash_mode
== 9600)
7598 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7600 office2013_t
*office2013
= &office2013s
[salt_pos
];
7602 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,
7608 office2013
->encryptedVerifier
[0],
7609 office2013
->encryptedVerifier
[1],
7610 office2013
->encryptedVerifier
[2],
7611 office2013
->encryptedVerifier
[3],
7612 office2013
->encryptedVerifierHash
[0],
7613 office2013
->encryptedVerifierHash
[1],
7614 office2013
->encryptedVerifierHash
[2],
7615 office2013
->encryptedVerifierHash
[3],
7616 office2013
->encryptedVerifierHash
[4],
7617 office2013
->encryptedVerifierHash
[5],
7618 office2013
->encryptedVerifierHash
[6],
7619 office2013
->encryptedVerifierHash
[7]);
7621 else if (hash_mode
== 9700)
7623 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7625 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7627 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7628 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7629 byte_swap_32 (salt
.salt_buf
[0]),
7630 byte_swap_32 (salt
.salt_buf
[1]),
7631 byte_swap_32 (salt
.salt_buf
[2]),
7632 byte_swap_32 (salt
.salt_buf
[3]),
7633 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7634 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7635 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7636 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7637 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7638 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7639 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7640 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7642 else if (hash_mode
== 9710)
7644 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7646 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7648 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7649 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7650 byte_swap_32 (salt
.salt_buf
[0]),
7651 byte_swap_32 (salt
.salt_buf
[1]),
7652 byte_swap_32 (salt
.salt_buf
[2]),
7653 byte_swap_32 (salt
.salt_buf
[3]),
7654 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7655 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7656 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7657 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7658 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7659 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7660 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7661 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7663 else if (hash_mode
== 9720)
7665 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7667 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7669 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7671 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7672 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7673 byte_swap_32 (salt
.salt_buf
[0]),
7674 byte_swap_32 (salt
.salt_buf
[1]),
7675 byte_swap_32 (salt
.salt_buf
[2]),
7676 byte_swap_32 (salt
.salt_buf
[3]),
7677 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7678 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7679 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7680 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7681 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7682 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7683 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7684 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7691 else if (hash_mode
== 9800)
7693 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7695 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7697 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7698 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7703 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7704 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7705 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7706 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7707 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7708 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7709 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7710 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7711 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7713 else if (hash_mode
== 9810)
7715 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7717 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7719 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7720 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7725 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7726 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7727 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7728 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7729 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7730 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7731 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7732 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7733 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7735 else if (hash_mode
== 9820)
7737 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7739 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7741 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7743 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7744 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7749 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7750 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7751 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7752 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7753 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7754 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7755 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7756 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7757 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7764 else if (hash_mode
== 10000)
7768 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7770 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7772 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7776 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7777 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7778 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7779 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7780 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7781 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7782 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7783 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7784 digest_buf
[8] = 0; // needed for base64_encode ()
7786 char tmp_buf
[64] = { 0 };
7788 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7792 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7794 else if (hash_mode
== 10100)
7796 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7801 byte_swap_32 (salt
.salt_buf
[0]),
7802 byte_swap_32 (salt
.salt_buf
[1]),
7803 byte_swap_32 (salt
.salt_buf
[2]),
7804 byte_swap_32 (salt
.salt_buf
[3]));
7806 else if (hash_mode
== 10200)
7808 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7810 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7814 char challenge
[100] = { 0 };
7816 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7820 char tmp_buf
[100] = { 0 };
7822 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7823 (char *) cram_md5
->user
,
7829 char response
[100] = { 0 };
7831 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7833 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7835 else if (hash_mode
== 10300)
7837 char tmp_buf
[100] = { 0 };
7839 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7840 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7842 uint tmp_len
= 20 + salt
.salt_len
;
7846 char base64_encoded
[100] = { 0 };
7848 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7850 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7852 else if (hash_mode
== 10400)
7854 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7856 pdf_t
*pdf
= &pdfs
[salt_pos
];
7858 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",
7866 byte_swap_32 (pdf
->id_buf
[0]),
7867 byte_swap_32 (pdf
->id_buf
[1]),
7868 byte_swap_32 (pdf
->id_buf
[2]),
7869 byte_swap_32 (pdf
->id_buf
[3]),
7871 byte_swap_32 (pdf
->u_buf
[0]),
7872 byte_swap_32 (pdf
->u_buf
[1]),
7873 byte_swap_32 (pdf
->u_buf
[2]),
7874 byte_swap_32 (pdf
->u_buf
[3]),
7875 byte_swap_32 (pdf
->u_buf
[4]),
7876 byte_swap_32 (pdf
->u_buf
[5]),
7877 byte_swap_32 (pdf
->u_buf
[6]),
7878 byte_swap_32 (pdf
->u_buf
[7]),
7880 byte_swap_32 (pdf
->o_buf
[0]),
7881 byte_swap_32 (pdf
->o_buf
[1]),
7882 byte_swap_32 (pdf
->o_buf
[2]),
7883 byte_swap_32 (pdf
->o_buf
[3]),
7884 byte_swap_32 (pdf
->o_buf
[4]),
7885 byte_swap_32 (pdf
->o_buf
[5]),
7886 byte_swap_32 (pdf
->o_buf
[6]),
7887 byte_swap_32 (pdf
->o_buf
[7])
7890 else if (hash_mode
== 10410)
7892 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7894 pdf_t
*pdf
= &pdfs
[salt_pos
];
7896 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",
7904 byte_swap_32 (pdf
->id_buf
[0]),
7905 byte_swap_32 (pdf
->id_buf
[1]),
7906 byte_swap_32 (pdf
->id_buf
[2]),
7907 byte_swap_32 (pdf
->id_buf
[3]),
7909 byte_swap_32 (pdf
->u_buf
[0]),
7910 byte_swap_32 (pdf
->u_buf
[1]),
7911 byte_swap_32 (pdf
->u_buf
[2]),
7912 byte_swap_32 (pdf
->u_buf
[3]),
7913 byte_swap_32 (pdf
->u_buf
[4]),
7914 byte_swap_32 (pdf
->u_buf
[5]),
7915 byte_swap_32 (pdf
->u_buf
[6]),
7916 byte_swap_32 (pdf
->u_buf
[7]),
7918 byte_swap_32 (pdf
->o_buf
[0]),
7919 byte_swap_32 (pdf
->o_buf
[1]),
7920 byte_swap_32 (pdf
->o_buf
[2]),
7921 byte_swap_32 (pdf
->o_buf
[3]),
7922 byte_swap_32 (pdf
->o_buf
[4]),
7923 byte_swap_32 (pdf
->o_buf
[5]),
7924 byte_swap_32 (pdf
->o_buf
[6]),
7925 byte_swap_32 (pdf
->o_buf
[7])
7928 else if (hash_mode
== 10420)
7930 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7932 pdf_t
*pdf
= &pdfs
[salt_pos
];
7934 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7936 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",
7944 byte_swap_32 (pdf
->id_buf
[0]),
7945 byte_swap_32 (pdf
->id_buf
[1]),
7946 byte_swap_32 (pdf
->id_buf
[2]),
7947 byte_swap_32 (pdf
->id_buf
[3]),
7949 byte_swap_32 (pdf
->u_buf
[0]),
7950 byte_swap_32 (pdf
->u_buf
[1]),
7951 byte_swap_32 (pdf
->u_buf
[2]),
7952 byte_swap_32 (pdf
->u_buf
[3]),
7953 byte_swap_32 (pdf
->u_buf
[4]),
7954 byte_swap_32 (pdf
->u_buf
[5]),
7955 byte_swap_32 (pdf
->u_buf
[6]),
7956 byte_swap_32 (pdf
->u_buf
[7]),
7958 byte_swap_32 (pdf
->o_buf
[0]),
7959 byte_swap_32 (pdf
->o_buf
[1]),
7960 byte_swap_32 (pdf
->o_buf
[2]),
7961 byte_swap_32 (pdf
->o_buf
[3]),
7962 byte_swap_32 (pdf
->o_buf
[4]),
7963 byte_swap_32 (pdf
->o_buf
[5]),
7964 byte_swap_32 (pdf
->o_buf
[6]),
7965 byte_swap_32 (pdf
->o_buf
[7]),
7973 else if (hash_mode
== 10500)
7975 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7977 pdf_t
*pdf
= &pdfs
[salt_pos
];
7979 if (pdf
->id_len
== 32)
7981 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",
7989 byte_swap_32 (pdf
->id_buf
[0]),
7990 byte_swap_32 (pdf
->id_buf
[1]),
7991 byte_swap_32 (pdf
->id_buf
[2]),
7992 byte_swap_32 (pdf
->id_buf
[3]),
7993 byte_swap_32 (pdf
->id_buf
[4]),
7994 byte_swap_32 (pdf
->id_buf
[5]),
7995 byte_swap_32 (pdf
->id_buf
[6]),
7996 byte_swap_32 (pdf
->id_buf
[7]),
7998 byte_swap_32 (pdf
->u_buf
[0]),
7999 byte_swap_32 (pdf
->u_buf
[1]),
8000 byte_swap_32 (pdf
->u_buf
[2]),
8001 byte_swap_32 (pdf
->u_buf
[3]),
8002 byte_swap_32 (pdf
->u_buf
[4]),
8003 byte_swap_32 (pdf
->u_buf
[5]),
8004 byte_swap_32 (pdf
->u_buf
[6]),
8005 byte_swap_32 (pdf
->u_buf
[7]),
8007 byte_swap_32 (pdf
->o_buf
[0]),
8008 byte_swap_32 (pdf
->o_buf
[1]),
8009 byte_swap_32 (pdf
->o_buf
[2]),
8010 byte_swap_32 (pdf
->o_buf
[3]),
8011 byte_swap_32 (pdf
->o_buf
[4]),
8012 byte_swap_32 (pdf
->o_buf
[5]),
8013 byte_swap_32 (pdf
->o_buf
[6]),
8014 byte_swap_32 (pdf
->o_buf
[7])
8019 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",
8027 byte_swap_32 (pdf
->id_buf
[0]),
8028 byte_swap_32 (pdf
->id_buf
[1]),
8029 byte_swap_32 (pdf
->id_buf
[2]),
8030 byte_swap_32 (pdf
->id_buf
[3]),
8032 byte_swap_32 (pdf
->u_buf
[0]),
8033 byte_swap_32 (pdf
->u_buf
[1]),
8034 byte_swap_32 (pdf
->u_buf
[2]),
8035 byte_swap_32 (pdf
->u_buf
[3]),
8036 byte_swap_32 (pdf
->u_buf
[4]),
8037 byte_swap_32 (pdf
->u_buf
[5]),
8038 byte_swap_32 (pdf
->u_buf
[6]),
8039 byte_swap_32 (pdf
->u_buf
[7]),
8041 byte_swap_32 (pdf
->o_buf
[0]),
8042 byte_swap_32 (pdf
->o_buf
[1]),
8043 byte_swap_32 (pdf
->o_buf
[2]),
8044 byte_swap_32 (pdf
->o_buf
[3]),
8045 byte_swap_32 (pdf
->o_buf
[4]),
8046 byte_swap_32 (pdf
->o_buf
[5]),
8047 byte_swap_32 (pdf
->o_buf
[6]),
8048 byte_swap_32 (pdf
->o_buf
[7])
8052 else if (hash_mode
== 10600)
8054 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8056 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8057 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8059 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8061 else if (hash_mode
== 10700)
8063 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8065 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8066 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8068 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8070 else if (hash_mode
== 10900)
8072 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8074 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8075 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8077 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8079 else if (hash_mode
== 11100)
8081 u32 salt_challenge
= salt
.salt_buf
[0];
8083 salt_challenge
= byte_swap_32 (salt_challenge
);
8085 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8087 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8088 SIGNATURE_POSTGRESQL_AUTH
,
8096 else if (hash_mode
== 11200)
8098 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8099 SIGNATURE_MYSQL_AUTH
,
8100 (unsigned char *) salt
.salt_buf
,
8107 else if (hash_mode
== 11300)
8109 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8111 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8113 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8114 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8115 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8117 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8118 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8119 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8121 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8123 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8125 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8128 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8130 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8132 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8135 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8137 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8139 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8142 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8143 SIGNATURE_BITCOIN_WALLET
,
8147 (unsigned char *) salt
.salt_buf
,
8155 free (cry_master_buf
);
8157 free (public_key_buf
);
8159 else if (hash_mode
== 11400)
8161 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8163 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8164 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8166 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8168 else if (hash_mode
== 11600)
8170 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8172 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8174 const uint data_len
= seven_zip
->data_len
;
8176 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8178 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8180 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8182 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8185 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8186 SIGNATURE_SEVEN_ZIP
,
8190 (char *) seven_zip
->salt_buf
,
8192 seven_zip
->iv_buf
[0],
8193 seven_zip
->iv_buf
[1],
8194 seven_zip
->iv_buf
[2],
8195 seven_zip
->iv_buf
[3],
8197 seven_zip
->data_len
,
8198 seven_zip
->unpack_size
,
8203 else if (hash_mode
== 11700)
8205 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8215 else if (hash_mode
== 11800)
8217 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8235 else if (hash_mode
== 11900)
8237 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8239 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8240 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8242 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8244 else if (hash_mode
== 12000)
8246 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8248 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8249 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8251 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8253 else if (hash_mode
== 12100)
8255 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8257 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8258 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8260 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8262 else if (hash_mode
== 12200)
8264 uint
*ptr_digest
= digest_buf
;
8265 uint
*ptr_salt
= salt
.salt_buf
;
8267 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8274 else if (hash_mode
== 12300)
8276 uint
*ptr_digest
= digest_buf
;
8277 uint
*ptr_salt
= salt
.salt_buf
;
8279 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",
8280 ptr_digest
[ 0], ptr_digest
[ 1],
8281 ptr_digest
[ 2], ptr_digest
[ 3],
8282 ptr_digest
[ 4], ptr_digest
[ 5],
8283 ptr_digest
[ 6], ptr_digest
[ 7],
8284 ptr_digest
[ 8], ptr_digest
[ 9],
8285 ptr_digest
[10], ptr_digest
[11],
8286 ptr_digest
[12], ptr_digest
[13],
8287 ptr_digest
[14], ptr_digest
[15],
8293 else if (hash_mode
== 12400)
8295 // encode iteration count
8297 char salt_iter
[5] = { 0 };
8299 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8300 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8301 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8302 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8307 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8308 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8309 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8310 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8315 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8317 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8318 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8320 memcpy (tmp_buf
, digest_buf
, 8);
8322 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8326 // fill the resulting buffer
8328 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8330 else if (hash_mode
== 12500)
8332 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8334 byte_swap_32 (salt
.salt_buf
[0]),
8335 byte_swap_32 (salt
.salt_buf
[1]),
8341 else if (hash_mode
== 12600)
8343 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8344 digest_buf
[0] + salt
.salt_buf_pc
[0],
8345 digest_buf
[1] + salt
.salt_buf_pc
[1],
8346 digest_buf
[2] + salt
.salt_buf_pc
[2],
8347 digest_buf
[3] + salt
.salt_buf_pc
[3],
8348 digest_buf
[4] + salt
.salt_buf_pc
[4],
8349 digest_buf
[5] + salt
.salt_buf_pc
[5],
8350 digest_buf
[6] + salt
.salt_buf_pc
[6],
8351 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8353 else if (hash_mode
== 12700)
8355 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8357 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8358 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8360 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8362 else if (hash_mode
== 12800)
8364 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8366 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",
8379 byte_swap_32 (digest_buf
[0]),
8380 byte_swap_32 (digest_buf
[1]),
8381 byte_swap_32 (digest_buf
[2]),
8382 byte_swap_32 (digest_buf
[3]),
8383 byte_swap_32 (digest_buf
[4]),
8384 byte_swap_32 (digest_buf
[5]),
8385 byte_swap_32 (digest_buf
[6]),
8386 byte_swap_32 (digest_buf
[7])
8389 else if (hash_mode
== 12900)
8391 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",
8400 byte_swap_32 (digest_buf
[0]),
8401 byte_swap_32 (digest_buf
[1]),
8402 byte_swap_32 (digest_buf
[2]),
8403 byte_swap_32 (digest_buf
[3]),
8404 byte_swap_32 (digest_buf
[4]),
8405 byte_swap_32 (digest_buf
[5]),
8406 byte_swap_32 (digest_buf
[6]),
8407 byte_swap_32 (digest_buf
[7]),
8414 else if (hash_mode
== 13000)
8416 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8418 rar5_t
*rar5
= &rar5s
[salt_pos
];
8420 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8430 byte_swap_32 (digest_buf
[0]),
8431 byte_swap_32 (digest_buf
[1])
8434 else if (hash_mode
== 13100)
8436 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8438 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8440 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8441 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8443 char data
[2560 * 4 * 2] = { 0 };
8445 char *ptr_data
= data
;
8447 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8448 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8453 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8454 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8456 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8458 (char *) krb5tgs
->account_info
,
8462 else if (hash_mode
== 13200)
8464 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8478 else if (hash_mode
== 13300)
8480 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8481 SIGNATURE_AXCRYPT_SHA1
,
8487 else if (hash_mode
== 13400)
8489 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8491 keepass_t
*keepass
= &keepasss
[salt_pos
];
8493 u32 version
= (u32
) keepass
->version
;
8494 u32 rounds
= salt
.salt_iter
;
8495 u32 algorithm
= (u32
) keepass
->algorithm
;
8496 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8498 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8499 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8500 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8501 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8502 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8504 /* specific to version 1 */
8508 /* specific to version 2 */
8509 u32 expected_bytes_len
;
8510 u32
*ptr_expected_bytes
;
8512 u32 final_random_seed_len
;
8513 u32 transf_random_seed_len
;
8515 u32 contents_hash_len
;
8517 transf_random_seed_len
= 8;
8519 contents_hash_len
= 8;
8520 final_random_seed_len
= 8;
8523 final_random_seed_len
= 4;
8525 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8531 char *ptr_data
= out_buf
;
8533 ptr_data
+= strlen(out_buf
);
8538 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8539 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8544 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8545 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8550 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8551 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8558 contents_len
= (u32
) keepass
->contents_len
;
8559 ptr_contents
= (u32
*) keepass
->contents
;
8561 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8562 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8574 char ptr_contents_len
[10] = { 0 };
8576 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8578 sprintf (ptr_data
, "%d", contents_len
);
8580 ptr_data
+= strlen(ptr_contents_len
);
8585 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8586 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8588 else if (version
== 2)
8590 expected_bytes_len
= 8;
8591 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8593 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8594 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8599 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8600 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8614 sprintf (ptr_data
, "%d", keyfile_len
);
8621 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8622 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8625 else if (hash_mode
== 13500)
8627 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8629 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8631 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8633 char pstoken_tmp
[1024 + 1] = { 0 };
8635 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8637 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8639 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8642 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8650 else if (hash_mode
== 13600)
8652 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8654 zip2_t
*zip2
= &zip2s
[salt_pos
];
8656 const u32 salt_len
= zip2
->salt_len
;
8658 char salt_tmp
[32 + 1] = { 0 };
8660 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8662 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8664 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8667 const u32 data_len
= zip2
->data_len
;
8669 char data_tmp
[8192 + 1] = { 0 };
8671 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8673 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8675 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8678 const u32 auth_len
= zip2
->auth_len
;
8680 char auth_tmp
[20 + 1] = { 0 };
8682 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8684 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8686 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8689 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8690 SIGNATURE_ZIP2_START
,
8696 zip2
->compress_length
,
8699 SIGNATURE_ZIP2_STOP
);
8701 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8703 snprintf (out_buf
, len
-1, "%s", hashfile
);
8707 if (hash_type
== HASH_TYPE_MD4
)
8709 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8715 else if (hash_type
== HASH_TYPE_MD5
)
8717 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8723 else if (hash_type
== HASH_TYPE_SHA1
)
8725 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8732 else if (hash_type
== HASH_TYPE_SHA256
)
8734 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8744 else if (hash_type
== HASH_TYPE_SHA384
)
8746 uint
*ptr
= digest_buf
;
8748 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8756 else if (hash_type
== HASH_TYPE_SHA512
)
8758 uint
*ptr
= digest_buf
;
8760 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8770 else if (hash_type
== HASH_TYPE_LM
)
8772 snprintf (out_buf
, len
-1, "%08x%08x",
8776 else if (hash_type
== HASH_TYPE_ORACLEH
)
8778 snprintf (out_buf
, len
-1, "%08X%08X",
8782 else if (hash_type
== HASH_TYPE_BCRYPT
)
8784 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8785 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8787 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8789 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8791 else if (hash_type
== HASH_TYPE_KECCAK
)
8793 uint
*ptr
= digest_buf
;
8795 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",
8823 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8825 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8827 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8834 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8836 digest_buf
[ 0] = digest_buf
[ 0];
8837 digest_buf
[ 1] = digest_buf
[ 1];
8838 digest_buf
[ 2] = digest_buf
[ 2];
8839 digest_buf
[ 3] = digest_buf
[ 3];
8840 digest_buf
[ 4] = digest_buf
[ 4];
8841 digest_buf
[ 5] = digest_buf
[ 5];
8842 digest_buf
[ 6] = digest_buf
[ 6];
8843 digest_buf
[ 7] = digest_buf
[ 7];
8844 digest_buf
[ 8] = digest_buf
[ 8];
8845 digest_buf
[ 9] = digest_buf
[ 9];
8846 digest_buf
[10] = digest_buf
[10];
8847 digest_buf
[11] = digest_buf
[11];
8848 digest_buf
[12] = digest_buf
[12];
8849 digest_buf
[13] = digest_buf
[13];
8850 digest_buf
[14] = digest_buf
[14];
8851 digest_buf
[15] = digest_buf
[15];
8853 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8871 else if (hash_type
== HASH_TYPE_GOST
)
8873 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8883 else if (hash_type
== HASH_TYPE_MYSQL
)
8885 snprintf (out_buf
, len
-1, "%08x%08x",
8889 else if (hash_type
== HASH_TYPE_LOTUS5
)
8891 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8897 else if (hash_type
== HASH_TYPE_LOTUS6
)
8899 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8900 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8901 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8902 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8904 char buf
[16] = { 0 };
8906 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8907 memcpy (buf
+ 5, digest_buf
, 9);
8911 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8913 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8916 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8918 else if (hash_type
== HASH_TYPE_LOTUS8
)
8920 char buf
[52] = { 0 };
8924 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8930 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8934 buf
[26] = salt
.salt_buf_pc
[0];
8935 buf
[27] = salt
.salt_buf_pc
[1];
8939 memcpy (buf
+ 28, digest_buf
, 8);
8941 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8945 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8947 else if (hash_type
== HASH_TYPE_CRC32
)
8949 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8953 if (salt_type
== SALT_TYPE_INTERN
)
8955 size_t pos
= strlen (out_buf
);
8957 out_buf
[pos
] = data
.separator
;
8959 char *ptr
= (char *) salt
.salt_buf
;
8961 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8963 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8967 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8969 memset (hccap
, 0, sizeof (hccap_t
));
8971 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8973 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8975 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8976 wpa_t
*wpa
= &wpas
[salt_pos
];
8978 hccap
->keyver
= wpa
->keyver
;
8980 hccap
->eapol_size
= wpa
->eapol_size
;
8982 if (wpa
->keyver
!= 1)
8984 uint eapol_tmp
[64] = { 0 };
8986 for (uint i
= 0; i
< 64; i
++)
8988 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8991 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8995 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8998 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8999 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9000 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9001 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9003 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9005 uint dgst_size
= data
.dgst_size
;
9007 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9009 if (wpa
->keyver
!= 1)
9011 uint digest_tmp
[4] = { 0 };
9013 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9014 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9015 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9016 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9018 memcpy (hccap
->keymic
, digest_tmp
, 16);
9022 memcpy (hccap
->keymic
, digest_ptr
, 16);
9026 void SuspendThreads ()
9028 if (data
.devices_status
== STATUS_RUNNING
)
9030 hc_timer_set (&data
.timer_paused
);
9032 data
.devices_status
= STATUS_PAUSED
;
9034 log_info ("Paused");
9038 void ResumeThreads ()
9040 if (data
.devices_status
== STATUS_PAUSED
)
9044 hc_timer_get (data
.timer_paused
, ms_paused
);
9046 data
.ms_paused
+= ms_paused
;
9048 data
.devices_status
= STATUS_RUNNING
;
9050 log_info ("Resumed");
9056 if (data
.devices_status
!= STATUS_RUNNING
) return;
9058 data
.devices_status
= STATUS_BYPASS
;
9060 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9063 void stop_at_checkpoint ()
9065 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9067 if (data
.devices_status
!= STATUS_RUNNING
) return;
9070 // this feature only makes sense if --restore-disable was not specified
9072 if (data
.restore_disable
== 1)
9074 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9079 // check if monitoring of Restore Point updates should be enabled or disabled
9081 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9083 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9085 // save the current restore point value
9087 data
.checkpoint_cur_words
= get_lowest_words_done ();
9089 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9093 data
.devices_status
= STATUS_RUNNING
;
9095 // reset the global value for checkpoint checks
9097 data
.checkpoint_cur_words
= 0;
9099 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9105 if (data
.devices_status
== STATUS_INIT
) return;
9106 if (data
.devices_status
== STATUS_STARTING
) return;
9108 data
.devices_status
= STATUS_ABORTED
;
9113 if (data
.devices_status
== STATUS_INIT
) return;
9114 if (data
.devices_status
== STATUS_STARTING
) return;
9116 data
.devices_status
= STATUS_QUIT
;
9119 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9121 FILE *fp
= fopen (kernel_file
, "rb");
9127 memset (&st
, 0, sizeof (st
));
9129 stat (kernel_file
, &st
);
9131 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9133 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9135 if (num_read
!= (size_t) st
.st_size
)
9137 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9144 buf
[st
.st_size
] = 0;
9146 for (int i
= 0; i
< num_devices
; i
++)
9148 kernel_lengths
[i
] = (size_t) st
.st_size
;
9150 kernel_sources
[i
] = buf
;
9155 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9163 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9165 if (binary_size
> 0)
9167 FILE *fp
= fopen (dst
, "wb");
9170 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9181 restore_data_t
*init_restore (int argc
, char **argv
)
9183 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9185 if (data
.restore_disable
== 0)
9187 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9191 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9195 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9204 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9206 int pidbin_len
= -1;
9209 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9211 FILE *fd
= fopen (pidbin
, "rb");
9215 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9217 pidbin
[pidbin_len
] = 0;
9221 char *argv0_r
= strrchr (argv
[0], '/');
9223 char *pidbin_r
= strrchr (pidbin
, '/');
9225 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9227 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9229 if (strcmp (argv0_r
, pidbin_r
) == 0)
9231 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9238 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9240 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9242 int pidbin2_len
= -1;
9244 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9245 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9247 pidbin
[pidbin_len
] = 0;
9248 pidbin2
[pidbin2_len
] = 0;
9252 if (strcmp (pidbin
, pidbin2
) == 0)
9254 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9267 if (rd
->version_bin
< RESTORE_MIN
)
9269 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9276 memset (rd
, 0, sizeof (restore_data_t
));
9278 rd
->version_bin
= VERSION_BIN
;
9281 rd
->pid
= getpid ();
9283 rd
->pid
= GetCurrentProcessId ();
9286 if (getcwd (rd
->cwd
, 255) == NULL
)
9299 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9301 FILE *fp
= fopen (eff_restore_file
, "rb");
9305 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9310 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9312 log_error ("ERROR: cannot read %s", eff_restore_file
);
9317 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9319 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9321 for (uint i
= 0; i
< rd
->argc
; i
++)
9323 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9325 log_error ("ERROR: cannot read %s", eff_restore_file
);
9330 size_t len
= strlen (buf
);
9332 if (len
) buf
[len
- 1] = 0;
9334 rd
->argv
[i
] = mystrdup (buf
);
9341 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9343 if (chdir (rd
->cwd
))
9345 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9346 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9347 " https://github.com/philsmd/analyze_hc_restore\n"
9348 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9354 u64
get_lowest_words_done ()
9358 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9360 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9362 if (device_param
->skipped
) continue;
9364 const u64 words_done
= device_param
->words_done
;
9366 if (words_done
< words_cur
) words_cur
= words_done
;
9369 // It's possible that a device's workload isn't finished right after a restore-case.
9370 // In that case, this function would return 0 and overwrite the real restore point
9371 // There's also data.words_cur which is set to rd->words_cur but it changes while
9372 // the attack is running therefore we should stick to rd->words_cur.
9373 // Note that -s influences rd->words_cur we should keep a close look on that.
9375 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9380 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9382 u64 words_cur
= get_lowest_words_done ();
9384 rd
->words_cur
= words_cur
;
9386 FILE *fp
= fopen (new_restore_file
, "wb");
9390 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9395 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9397 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9402 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9404 for (uint i
= 0; i
< rd
->argc
; i
++)
9406 fprintf (fp
, "%s", rd
->argv
[i
]);
9412 fsync (fileno (fp
));
9417 void cycle_restore ()
9419 const char *eff_restore_file
= data
.eff_restore_file
;
9420 const char *new_restore_file
= data
.new_restore_file
;
9422 restore_data_t
*rd
= data
.rd
;
9424 write_restore (new_restore_file
, rd
);
9428 memset (&st
, 0, sizeof(st
));
9430 if (stat (eff_restore_file
, &st
) == 0)
9432 if (unlink (eff_restore_file
))
9434 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9438 if (rename (new_restore_file
, eff_restore_file
))
9440 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9444 void check_checkpoint ()
9446 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9448 u64 words_cur
= get_lowest_words_done ();
9450 if (words_cur
!= data
.checkpoint_cur_words
)
9460 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9464 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9466 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9468 myfree (alias
->device_name
);
9469 myfree (alias
->alias_name
);
9472 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9474 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9476 myfree (entry
->device_name
);
9479 myfree (tuning_db
->alias_buf
);
9480 myfree (tuning_db
->entry_buf
);
9485 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9487 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9489 int num_lines
= count_lines (fp
);
9491 // a bit over-allocated
9493 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9494 tuning_db
->alias_cnt
= 0;
9496 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9497 tuning_db
->entry_cnt
= 0;
9502 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9504 FILE *fp
= fopen (tuning_db_file
, "rb");
9508 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9513 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9519 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9523 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9525 if (line_buf
== NULL
) break;
9529 const int line_len
= in_superchop (line_buf
);
9531 if (line_len
== 0) continue;
9533 if (line_buf
[0] == '#') continue;
9537 char *token_ptr
[7] = { NULL
};
9541 char *next
= strtok (line_buf
, "\t ");
9543 token_ptr
[token_cnt
] = next
;
9547 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9549 token_ptr
[token_cnt
] = next
;
9556 char *device_name
= token_ptr
[0];
9557 char *alias_name
= token_ptr
[1];
9559 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9561 alias
->device_name
= mystrdup (device_name
);
9562 alias
->alias_name
= mystrdup (alias_name
);
9564 tuning_db
->alias_cnt
++;
9566 else if (token_cnt
== 6)
9568 if ((token_ptr
[1][0] != '0') &&
9569 (token_ptr
[1][0] != '1') &&
9570 (token_ptr
[1][0] != '3') &&
9571 (token_ptr
[1][0] != '*'))
9573 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9578 if ((token_ptr
[3][0] != '1') &&
9579 (token_ptr
[3][0] != '2') &&
9580 (token_ptr
[3][0] != '4') &&
9581 (token_ptr
[3][0] != '8') &&
9582 (token_ptr
[3][0] != 'N'))
9584 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9589 char *device_name
= token_ptr
[0];
9591 int attack_mode
= -1;
9593 int vector_width
= -1;
9594 int kernel_accel
= -1;
9595 int kernel_loops
= -1;
9597 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9598 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9599 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9601 if (token_ptr
[4][0] != 'A')
9603 kernel_accel
= atoi (token_ptr
[4]);
9605 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9607 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9617 if (token_ptr
[5][0] != 'A')
9619 kernel_loops
= atoi (token_ptr
[5]);
9621 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9623 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9633 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9635 entry
->device_name
= mystrdup (device_name
);
9636 entry
->attack_mode
= attack_mode
;
9637 entry
->hash_type
= hash_type
;
9638 entry
->vector_width
= vector_width
;
9639 entry
->kernel_accel
= kernel_accel
;
9640 entry
->kernel_loops
= kernel_loops
;
9642 tuning_db
->entry_cnt
++;
9646 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9656 // todo: print loaded 'cnt' message
9658 // sort the database
9660 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9661 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9666 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9668 static tuning_db_entry_t s
;
9670 // first we need to convert all spaces in the device_name to underscore
9672 char *device_name_nospace
= strdup (device_param
->device_name
);
9674 int device_name_length
= strlen (device_name_nospace
);
9678 for (i
= 0; i
< device_name_length
; i
++)
9680 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9683 // find out if there's an alias configured
9685 tuning_db_alias_t a
;
9687 a
.device_name
= device_name_nospace
;
9689 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
);
9691 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9693 // attack-mode 6 and 7 are attack-mode 1 basically
9695 if (attack_mode
== 6) attack_mode
= 1;
9696 if (attack_mode
== 7) attack_mode
= 1;
9698 // bsearch is not ideal but fast enough
9700 s
.device_name
= device_name_nospace
;
9701 s
.attack_mode
= attack_mode
;
9702 s
.hash_type
= hash_type
;
9704 tuning_db_entry_t
*entry
= NULL
;
9706 // this will produce all 2^3 combinations required
9708 for (i
= 0; i
< 8; i
++)
9710 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9711 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9712 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9714 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9716 if (entry
!= NULL
) break;
9718 // in non-wildcard mode do some additional checks:
9722 // in case we have an alias-name
9724 if (alias_name
!= NULL
)
9726 s
.device_name
= alias_name
;
9728 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9730 if (entry
!= NULL
) break;
9733 // or by device type
9735 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9737 s
.device_name
= "DEVICE_TYPE_CPU";
9739 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9741 s
.device_name
= "DEVICE_TYPE_GPU";
9743 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9745 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9748 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9750 if (entry
!= NULL
) break;
9754 // free converted device_name
9756 myfree (device_name_nospace
);
9765 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9767 u8 tmp
[256] = { 0 };
9769 if (salt_len
> sizeof (tmp
))
9774 memcpy (tmp
, in
, salt_len
);
9776 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9778 if ((salt_len
% 2) == 0)
9780 u32 new_salt_len
= salt_len
/ 2;
9782 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9787 tmp
[i
] = hex_convert (p1
) << 0;
9788 tmp
[i
] |= hex_convert (p0
) << 4;
9791 salt_len
= new_salt_len
;
9798 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9800 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9803 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9805 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9809 u32
*tmp_uint
= (u32
*) tmp
;
9811 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9812 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9813 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9814 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9815 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9816 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9817 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9818 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9819 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9820 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9822 salt_len
= salt_len
* 2;
9830 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9832 lowercase (tmp
, salt_len
);
9835 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9837 uppercase (tmp
, salt_len
);
9842 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9847 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9852 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9854 u32
*tmp_uint
= (uint
*) tmp
;
9860 for (u32 i
= 0; i
< max
; i
++)
9862 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9865 // Important: we may need to increase the length of memcpy since
9866 // we don't want to "loose" some swapped bytes (could happen if
9867 // they do not perfectly fit in the 4-byte blocks)
9868 // Memcpy does always copy the bytes in the BE order, but since
9869 // we swapped them, some important bytes could be in positions
9870 // we normally skip with the original len
9872 if (len
% 4) len
+= 4 - (len
% 4);
9875 memcpy (out
, tmp
, len
);
9880 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9882 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9884 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9886 u32
*digest
= (u32
*) hash_buf
->digest
;
9888 salt_t
*salt
= hash_buf
->salt
;
9890 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9892 char *iter_pos
= input_buf
+ 4;
9894 salt
->salt_iter
= 1 << atoi (iter_pos
);
9896 char *salt_pos
= strchr (iter_pos
, '$');
9898 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9904 salt
->salt_len
= salt_len
;
9906 u8 tmp_buf
[100] = { 0 };
9908 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9910 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9912 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9914 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9915 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9916 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9917 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9919 char *hash_pos
= salt_pos
+ 22;
9921 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9923 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9925 memcpy (digest
, tmp_buf
, 24);
9927 digest
[0] = byte_swap_32 (digest
[0]);
9928 digest
[1] = byte_swap_32 (digest
[1]);
9929 digest
[2] = byte_swap_32 (digest
[2]);
9930 digest
[3] = byte_swap_32 (digest
[3]);
9931 digest
[4] = byte_swap_32 (digest
[4]);
9932 digest
[5] = byte_swap_32 (digest
[5]);
9934 digest
[5] &= ~0xff; // its just 23 not 24 !
9939 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9941 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9943 u32
*digest
= (u32
*) hash_buf
->digest
;
9945 u8 tmp_buf
[100] = { 0 };
9947 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9949 memcpy (digest
, tmp_buf
, 32);
9951 digest
[0] = byte_swap_32 (digest
[0]);
9952 digest
[1] = byte_swap_32 (digest
[1]);
9953 digest
[2] = byte_swap_32 (digest
[2]);
9954 digest
[3] = byte_swap_32 (digest
[3]);
9955 digest
[4] = byte_swap_32 (digest
[4]);
9956 digest
[5] = byte_swap_32 (digest
[5]);
9957 digest
[6] = byte_swap_32 (digest
[6]);
9958 digest
[7] = byte_swap_32 (digest
[7]);
9960 digest
[0] -= SHA256M_A
;
9961 digest
[1] -= SHA256M_B
;
9962 digest
[2] -= SHA256M_C
;
9963 digest
[3] -= SHA256M_D
;
9964 digest
[4] -= SHA256M_E
;
9965 digest
[5] -= SHA256M_F
;
9966 digest
[6] -= SHA256M_G
;
9967 digest
[7] -= SHA256M_H
;
9972 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9974 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9976 u32
*digest
= (u32
*) hash_buf
->digest
;
9978 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9979 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9981 digest
[0] = byte_swap_32 (digest
[0]);
9982 digest
[1] = byte_swap_32 (digest
[1]);
9986 IP (digest
[0], digest
[1], tt
);
9988 digest
[0] = digest
[0];
9989 digest
[1] = digest
[1];
9996 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9998 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10000 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10002 u32
*digest
= (u32
*) hash_buf
->digest
;
10004 salt_t
*salt
= hash_buf
->salt
;
10006 char *hash_pos
= input_buf
+ 10;
10008 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10009 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10010 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10011 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10012 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10014 digest
[0] -= SHA1M_A
;
10015 digest
[1] -= SHA1M_B
;
10016 digest
[2] -= SHA1M_C
;
10017 digest
[3] -= SHA1M_D
;
10018 digest
[4] -= SHA1M_E
;
10020 uint salt_len
= 10;
10022 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10024 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10026 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10028 salt
->salt_len
= salt_len
;
10030 return (PARSER_OK
);
10033 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10035 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10037 u32
*digest
= (u32
*) hash_buf
->digest
;
10039 salt_t
*salt
= hash_buf
->salt
;
10041 char *hash_pos
= input_buf
+ 8;
10043 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10044 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10045 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10046 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10047 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10049 digest
[0] -= SHA1M_A
;
10050 digest
[1] -= SHA1M_B
;
10051 digest
[2] -= SHA1M_C
;
10052 digest
[3] -= SHA1M_D
;
10053 digest
[4] -= SHA1M_E
;
10057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10059 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10063 salt
->salt_len
= salt_len
;
10065 return (PARSER_OK
);
10068 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10070 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10072 u64
*digest
= (u64
*) hash_buf
->digest
;
10074 salt_t
*salt
= hash_buf
->salt
;
10076 char *hash_pos
= input_buf
+ 8;
10078 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10079 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10080 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10081 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10082 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10083 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10084 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10085 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10087 digest
[0] -= SHA512M_A
;
10088 digest
[1] -= SHA512M_B
;
10089 digest
[2] -= SHA512M_C
;
10090 digest
[3] -= SHA512M_D
;
10091 digest
[4] -= SHA512M_E
;
10092 digest
[5] -= SHA512M_F
;
10093 digest
[6] -= SHA512M_G
;
10094 digest
[7] -= SHA512M_H
;
10098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10100 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10104 salt
->salt_len
= salt_len
;
10106 return (PARSER_OK
);
10109 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10111 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10113 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10117 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10120 u32
*digest
= (u32
*) hash_buf
->digest
;
10122 salt_t
*salt
= hash_buf
->salt
;
10124 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10125 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10126 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10127 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10129 digest
[0] = byte_swap_32 (digest
[0]);
10130 digest
[1] = byte_swap_32 (digest
[1]);
10131 digest
[2] = byte_swap_32 (digest
[2]);
10132 digest
[3] = byte_swap_32 (digest
[3]);
10134 digest
[0] -= MD5M_A
;
10135 digest
[1] -= MD5M_B
;
10136 digest
[2] -= MD5M_C
;
10137 digest
[3] -= MD5M_D
;
10139 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10141 uint salt_len
= input_len
- 32 - 1;
10143 char *salt_buf
= input_buf
+ 32 + 1;
10145 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10151 salt
->salt_len
= salt_len
;
10153 return (PARSER_OK
);
10156 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10158 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10160 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10164 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10169 char clean_input_buf
[32] = { 0 };
10171 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10172 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10174 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10178 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10184 clean_input_buf
[k
] = input_buf
[i
];
10192 u32
*digest
= (u32
*) hash_buf
->digest
;
10194 salt_t
*salt
= hash_buf
->salt
;
10196 u32 a
, b
, c
, d
, e
, f
;
10198 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10199 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10200 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10201 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10202 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10203 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10205 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10206 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10208 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10209 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10210 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10211 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10212 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10213 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10215 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10216 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10218 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10219 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10220 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10221 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10222 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10223 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10225 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10226 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10228 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10229 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10230 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10231 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10232 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10233 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10235 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10236 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10238 digest
[0] = byte_swap_32 (digest
[0]);
10239 digest
[1] = byte_swap_32 (digest
[1]);
10240 digest
[2] = byte_swap_32 (digest
[2]);
10241 digest
[3] = byte_swap_32 (digest
[3]);
10243 digest
[0] -= MD5M_A
;
10244 digest
[1] -= MD5M_B
;
10245 digest
[2] -= MD5M_C
;
10246 digest
[3] -= MD5M_D
;
10248 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10250 uint salt_len
= input_len
- 30 - 1;
10252 char *salt_buf
= input_buf
+ 30 + 1;
10254 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10256 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10258 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10259 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10261 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10263 salt
->salt_len
= salt_len
;
10265 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10267 salt
->salt_len
+= 22;
10269 return (PARSER_OK
);
10272 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10274 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10276 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10280 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10283 u32
*digest
= (u32
*) hash_buf
->digest
;
10285 salt_t
*salt
= hash_buf
->salt
;
10287 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10288 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10289 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10290 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10291 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10293 digest
[0] -= SHA1M_A
;
10294 digest
[1] -= SHA1M_B
;
10295 digest
[2] -= SHA1M_C
;
10296 digest
[3] -= SHA1M_D
;
10297 digest
[4] -= SHA1M_E
;
10299 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10301 uint salt_len
= input_len
- 40 - 1;
10303 char *salt_buf
= input_buf
+ 40 + 1;
10305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10307 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10309 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10311 salt
->salt_len
= salt_len
;
10313 return (PARSER_OK
);
10316 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10318 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10320 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10324 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10327 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10329 char *iter_pos
= input_buf
+ 6;
10331 salt_t
*salt
= hash_buf
->salt
;
10333 uint iter
= atoi (iter_pos
);
10337 iter
= ROUNDS_DCC2
;
10340 salt
->salt_iter
= iter
- 1;
10342 char *salt_pos
= strchr (iter_pos
, '#');
10344 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10348 char *digest_pos
= strchr (salt_pos
, '#');
10350 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10354 uint salt_len
= digest_pos
- salt_pos
- 1;
10356 u32
*digest
= (u32
*) hash_buf
->digest
;
10358 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10359 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10360 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10361 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10369 salt
->salt_len
= salt_len
;
10371 return (PARSER_OK
);
10374 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10376 u32
*digest
= (u32
*) hash_buf
->digest
;
10378 salt_t
*salt
= hash_buf
->salt
;
10380 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10384 memcpy (&in
, input_buf
, input_len
);
10386 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10388 memcpy (digest
, in
.keymic
, 16);
10391 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10392 The phrase "Pairwise key expansion"
10393 Access Point Address (referred to as Authenticator Address AA)
10394 Supplicant Address (referred to as Supplicant Address SA)
10395 Access Point Nonce (referred to as Authenticator Anonce)
10396 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10399 uint salt_len
= strlen (in
.essid
);
10403 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10405 return (PARSER_SALT_LENGTH
);
10408 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10410 salt
->salt_len
= salt_len
;
10412 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10414 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10416 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10418 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10420 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10421 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10425 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10426 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10429 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10431 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10432 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10436 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10437 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10440 for (int i
= 0; i
< 25; i
++)
10442 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10445 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10446 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10447 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10448 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10450 wpa
->keyver
= in
.keyver
;
10452 if (wpa
->keyver
> 255)
10454 log_info ("ATTENTION!");
10455 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10456 log_info (" This could be due to a recent aircrack-ng bug.");
10457 log_info (" The key version was automatically reset to a reasonable value.");
10460 wpa
->keyver
&= 0xff;
10463 wpa
->eapol_size
= in
.eapol_size
;
10465 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10467 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10469 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10471 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10473 if (wpa
->keyver
== 1)
10479 digest
[0] = byte_swap_32 (digest
[0]);
10480 digest
[1] = byte_swap_32 (digest
[1]);
10481 digest
[2] = byte_swap_32 (digest
[2]);
10482 digest
[3] = byte_swap_32 (digest
[3]);
10484 for (int i
= 0; i
< 64; i
++)
10486 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10490 uint32_t *p0
= (uint32_t *) in
.essid
;
10494 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10495 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10497 salt
->salt_buf
[10] = c0
;
10498 salt
->salt_buf
[11] = c1
;
10500 return (PARSER_OK
);
10503 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10505 u32
*digest
= (u32
*) hash_buf
->digest
;
10507 salt_t
*salt
= hash_buf
->salt
;
10509 if (input_len
== 0)
10511 log_error ("Password Safe v2 container not specified");
10516 FILE *fp
= fopen (input_buf
, "rb");
10520 log_error ("%s: %s", input_buf
, strerror (errno
));
10527 memset (&buf
, 0, sizeof (psafe2_hdr
));
10529 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10533 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10535 salt
->salt_buf
[0] = buf
.random
[0];
10536 salt
->salt_buf
[1] = buf
.random
[1];
10538 salt
->salt_len
= 8;
10539 salt
->salt_iter
= 1000;
10541 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10542 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10543 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10544 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10545 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10547 return (PARSER_OK
);
10550 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10552 u32
*digest
= (u32
*) hash_buf
->digest
;
10554 salt_t
*salt
= hash_buf
->salt
;
10556 if (input_len
== 0)
10558 log_error (".psafe3 not specified");
10563 FILE *fp
= fopen (input_buf
, "rb");
10567 log_error ("%s: %s", input_buf
, strerror (errno
));
10574 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10578 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10580 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10582 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10584 salt
->salt_iter
= in
.iterations
+ 1;
10586 salt
->salt_buf
[0] = in
.salt_buf
[0];
10587 salt
->salt_buf
[1] = in
.salt_buf
[1];
10588 salt
->salt_buf
[2] = in
.salt_buf
[2];
10589 salt
->salt_buf
[3] = in
.salt_buf
[3];
10590 salt
->salt_buf
[4] = in
.salt_buf
[4];
10591 salt
->salt_buf
[5] = in
.salt_buf
[5];
10592 salt
->salt_buf
[6] = in
.salt_buf
[6];
10593 salt
->salt_buf
[7] = in
.salt_buf
[7];
10595 salt
->salt_len
= 32;
10597 digest
[0] = in
.hash_buf
[0];
10598 digest
[1] = in
.hash_buf
[1];
10599 digest
[2] = in
.hash_buf
[2];
10600 digest
[3] = in
.hash_buf
[3];
10601 digest
[4] = in
.hash_buf
[4];
10602 digest
[5] = in
.hash_buf
[5];
10603 digest
[6] = in
.hash_buf
[6];
10604 digest
[7] = in
.hash_buf
[7];
10606 digest
[0] = byte_swap_32 (digest
[0]);
10607 digest
[1] = byte_swap_32 (digest
[1]);
10608 digest
[2] = byte_swap_32 (digest
[2]);
10609 digest
[3] = byte_swap_32 (digest
[3]);
10610 digest
[4] = byte_swap_32 (digest
[4]);
10611 digest
[5] = byte_swap_32 (digest
[5]);
10612 digest
[6] = byte_swap_32 (digest
[6]);
10613 digest
[7] = byte_swap_32 (digest
[7]);
10615 return (PARSER_OK
);
10618 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10620 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10622 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10624 u32
*digest
= (u32
*) hash_buf
->digest
;
10626 salt_t
*salt
= hash_buf
->salt
;
10628 char *iter_pos
= input_buf
+ 3;
10630 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10632 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10634 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10636 salt
->salt_iter
= salt_iter
;
10638 char *salt_pos
= iter_pos
+ 1;
10642 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10644 salt
->salt_len
= salt_len
;
10646 char *hash_pos
= salt_pos
+ salt_len
;
10648 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10650 return (PARSER_OK
);
10653 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10655 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10657 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10659 u32
*digest
= (u32
*) hash_buf
->digest
;
10661 salt_t
*salt
= hash_buf
->salt
;
10663 char *salt_pos
= input_buf
+ 3;
10665 uint iterations_len
= 0;
10667 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10671 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10673 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10674 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10678 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10682 iterations_len
+= 8;
10686 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10689 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10691 char *hash_pos
= strchr (salt_pos
, '$');
10693 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10695 uint salt_len
= hash_pos
- salt_pos
;
10697 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10699 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10701 salt
->salt_len
= salt_len
;
10705 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10707 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10709 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10711 return (PARSER_OK
);
10714 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10716 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10718 u32
*digest
= (u32
*) hash_buf
->digest
;
10720 salt_t
*salt
= hash_buf
->salt
;
10722 char *salt_pos
= input_buf
+ 6;
10724 uint iterations_len
= 0;
10726 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10730 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10732 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10733 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10737 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10741 iterations_len
+= 8;
10745 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10748 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10750 char *hash_pos
= strchr (salt_pos
, '$');
10752 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10754 uint salt_len
= hash_pos
- salt_pos
;
10756 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10758 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10760 salt
->salt_len
= salt_len
;
10764 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10766 return (PARSER_OK
);
10769 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10771 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10773 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10775 u32
*digest
= (u32
*) hash_buf
->digest
;
10777 salt_t
*salt
= hash_buf
->salt
;
10779 char *salt_pos
= input_buf
+ 14;
10781 char *hash_pos
= strchr (salt_pos
, '*');
10783 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10787 uint salt_len
= hash_pos
- salt_pos
- 1;
10789 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10791 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10793 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10795 salt
->salt_len
= salt_len
;
10797 u8 tmp_buf
[100] = { 0 };
10799 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10801 memcpy (digest
, tmp_buf
, 20);
10803 digest
[0] = byte_swap_32 (digest
[0]);
10804 digest
[1] = byte_swap_32 (digest
[1]);
10805 digest
[2] = byte_swap_32 (digest
[2]);
10806 digest
[3] = byte_swap_32 (digest
[3]);
10807 digest
[4] = byte_swap_32 (digest
[4]);
10809 digest
[0] -= SHA1M_A
;
10810 digest
[1] -= SHA1M_B
;
10811 digest
[2] -= SHA1M_C
;
10812 digest
[3] -= SHA1M_D
;
10813 digest
[4] -= SHA1M_E
;
10815 return (PARSER_OK
);
10818 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10820 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10822 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10824 if (c12
& 3) return (PARSER_HASH_VALUE
);
10826 u32
*digest
= (u32
*) hash_buf
->digest
;
10828 salt_t
*salt
= hash_buf
->salt
;
10830 // for ascii_digest
10831 salt
->salt_sign
[0] = input_buf
[0];
10832 salt
->salt_sign
[1] = input_buf
[1];
10834 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10835 | itoa64_to_int (input_buf
[1]) << 6;
10837 salt
->salt_len
= 2;
10839 u8 tmp_buf
[100] = { 0 };
10841 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10843 memcpy (digest
, tmp_buf
, 8);
10847 IP (digest
[0], digest
[1], tt
);
10852 return (PARSER_OK
);
10855 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10857 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10859 u32
*digest
= (u32
*) hash_buf
->digest
;
10861 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10862 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10863 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10864 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10866 digest
[0] = byte_swap_32 (digest
[0]);
10867 digest
[1] = byte_swap_32 (digest
[1]);
10868 digest
[2] = byte_swap_32 (digest
[2]);
10869 digest
[3] = byte_swap_32 (digest
[3]);
10871 digest
[0] -= MD4M_A
;
10872 digest
[1] -= MD4M_B
;
10873 digest
[2] -= MD4M_C
;
10874 digest
[3] -= MD4M_D
;
10876 return (PARSER_OK
);
10879 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10881 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10883 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10887 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10890 u32
*digest
= (u32
*) hash_buf
->digest
;
10892 salt_t
*salt
= hash_buf
->salt
;
10894 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10895 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10896 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10897 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10899 digest
[0] = byte_swap_32 (digest
[0]);
10900 digest
[1] = byte_swap_32 (digest
[1]);
10901 digest
[2] = byte_swap_32 (digest
[2]);
10902 digest
[3] = byte_swap_32 (digest
[3]);
10904 digest
[0] -= MD4M_A
;
10905 digest
[1] -= MD4M_B
;
10906 digest
[2] -= MD4M_C
;
10907 digest
[3] -= MD4M_D
;
10909 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10911 uint salt_len
= input_len
- 32 - 1;
10913 char *salt_buf
= input_buf
+ 32 + 1;
10915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10921 salt
->salt_len
= salt_len
;
10923 return (PARSER_OK
);
10926 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10928 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10930 u32
*digest
= (u32
*) hash_buf
->digest
;
10932 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10933 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10934 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10935 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10937 digest
[0] = byte_swap_32 (digest
[0]);
10938 digest
[1] = byte_swap_32 (digest
[1]);
10939 digest
[2] = byte_swap_32 (digest
[2]);
10940 digest
[3] = byte_swap_32 (digest
[3]);
10942 digest
[0] -= MD5M_A
;
10943 digest
[1] -= MD5M_B
;
10944 digest
[2] -= MD5M_C
;
10945 digest
[3] -= MD5M_D
;
10947 return (PARSER_OK
);
10950 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10952 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10954 u32
*digest
= (u32
*) hash_buf
->digest
;
10956 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10957 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10961 digest
[0] = byte_swap_32 (digest
[0]);
10962 digest
[1] = byte_swap_32 (digest
[1]);
10964 return (PARSER_OK
);
10967 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10969 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10971 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10975 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10978 u32
*digest
= (u32
*) hash_buf
->digest
;
10980 salt_t
*salt
= hash_buf
->salt
;
10982 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10983 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10984 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10985 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10987 digest
[0] = byte_swap_32 (digest
[0]);
10988 digest
[1] = byte_swap_32 (digest
[1]);
10989 digest
[2] = byte_swap_32 (digest
[2]);
10990 digest
[3] = byte_swap_32 (digest
[3]);
10992 digest
[0] -= MD5M_A
;
10993 digest
[1] -= MD5M_B
;
10994 digest
[2] -= MD5M_C
;
10995 digest
[3] -= MD5M_D
;
10997 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10999 uint salt_len
= input_len
- 32 - 1;
11001 char *salt_buf
= input_buf
+ 32 + 1;
11003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11009 salt
->salt_len
= salt_len
;
11011 return (PARSER_OK
);
11014 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11016 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11018 u32
*digest
= (u32
*) hash_buf
->digest
;
11020 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11021 | itoa64_to_int (input_buf
[ 1]) << 6
11022 | itoa64_to_int (input_buf
[ 2]) << 12
11023 | itoa64_to_int (input_buf
[ 3]) << 18;
11024 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11025 | itoa64_to_int (input_buf
[ 5]) << 6
11026 | itoa64_to_int (input_buf
[ 6]) << 12
11027 | itoa64_to_int (input_buf
[ 7]) << 18;
11028 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11029 | itoa64_to_int (input_buf
[ 9]) << 6
11030 | itoa64_to_int (input_buf
[10]) << 12
11031 | itoa64_to_int (input_buf
[11]) << 18;
11032 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11033 | itoa64_to_int (input_buf
[13]) << 6
11034 | itoa64_to_int (input_buf
[14]) << 12
11035 | itoa64_to_int (input_buf
[15]) << 18;
11037 digest
[0] -= MD5M_A
;
11038 digest
[1] -= MD5M_B
;
11039 digest
[2] -= MD5M_C
;
11040 digest
[3] -= MD5M_D
;
11042 digest
[0] &= 0x00ffffff;
11043 digest
[1] &= 0x00ffffff;
11044 digest
[2] &= 0x00ffffff;
11045 digest
[3] &= 0x00ffffff;
11047 return (PARSER_OK
);
11050 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11052 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11054 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11058 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11061 u32
*digest
= (u32
*) hash_buf
->digest
;
11063 salt_t
*salt
= hash_buf
->salt
;
11065 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11066 | itoa64_to_int (input_buf
[ 1]) << 6
11067 | itoa64_to_int (input_buf
[ 2]) << 12
11068 | itoa64_to_int (input_buf
[ 3]) << 18;
11069 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11070 | itoa64_to_int (input_buf
[ 5]) << 6
11071 | itoa64_to_int (input_buf
[ 6]) << 12
11072 | itoa64_to_int (input_buf
[ 7]) << 18;
11073 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11074 | itoa64_to_int (input_buf
[ 9]) << 6
11075 | itoa64_to_int (input_buf
[10]) << 12
11076 | itoa64_to_int (input_buf
[11]) << 18;
11077 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11078 | itoa64_to_int (input_buf
[13]) << 6
11079 | itoa64_to_int (input_buf
[14]) << 12
11080 | itoa64_to_int (input_buf
[15]) << 18;
11082 digest
[0] -= MD5M_A
;
11083 digest
[1] -= MD5M_B
;
11084 digest
[2] -= MD5M_C
;
11085 digest
[3] -= MD5M_D
;
11087 digest
[0] &= 0x00ffffff;
11088 digest
[1] &= 0x00ffffff;
11089 digest
[2] &= 0x00ffffff;
11090 digest
[3] &= 0x00ffffff;
11092 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11094 uint salt_len
= input_len
- 16 - 1;
11096 char *salt_buf
= input_buf
+ 16 + 1;
11098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11104 salt
->salt_len
= salt_len
;
11106 return (PARSER_OK
);
11109 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11111 key
[0] = (nthash
[0] >> 0);
11112 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11113 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11114 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11115 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11116 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11117 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11118 key
[7] = (nthash
[6] << 1);
11130 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11132 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11134 u32
*digest
= (u32
*) hash_buf
->digest
;
11136 salt_t
*salt
= hash_buf
->salt
;
11138 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11144 char *user_pos
= input_buf
;
11146 char *unused_pos
= strchr (user_pos
, ':');
11148 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11150 uint user_len
= unused_pos
- user_pos
;
11152 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11156 char *domain_pos
= strchr (unused_pos
, ':');
11158 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11160 uint unused_len
= domain_pos
- unused_pos
;
11162 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11166 char *srvchall_pos
= strchr (domain_pos
, ':');
11168 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11170 uint domain_len
= srvchall_pos
- domain_pos
;
11172 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11176 char *hash_pos
= strchr (srvchall_pos
, ':');
11178 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11180 uint srvchall_len
= hash_pos
- srvchall_pos
;
11182 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11186 char *clichall_pos
= strchr (hash_pos
, ':');
11188 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11190 uint hash_len
= clichall_pos
- hash_pos
;
11192 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11196 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11198 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11201 * store some data for later use
11204 netntlm
->user_len
= user_len
* 2;
11205 netntlm
->domain_len
= domain_len
* 2;
11206 netntlm
->srvchall_len
= srvchall_len
/ 2;
11207 netntlm
->clichall_len
= clichall_len
/ 2;
11209 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11210 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11213 * handle username and domainname
11216 for (uint i
= 0; i
< user_len
; i
++)
11218 *userdomain_ptr
++ = user_pos
[i
];
11219 *userdomain_ptr
++ = 0;
11222 for (uint i
= 0; i
< domain_len
; i
++)
11224 *userdomain_ptr
++ = domain_pos
[i
];
11225 *userdomain_ptr
++ = 0;
11229 * handle server challenge encoding
11232 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11234 const char p0
= srvchall_pos
[i
+ 0];
11235 const char p1
= srvchall_pos
[i
+ 1];
11237 *chall_ptr
++ = hex_convert (p1
) << 0
11238 | hex_convert (p0
) << 4;
11242 * handle client challenge encoding
11245 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11247 const char p0
= clichall_pos
[i
+ 0];
11248 const char p1
= clichall_pos
[i
+ 1];
11250 *chall_ptr
++ = hex_convert (p1
) << 0
11251 | hex_convert (p0
) << 4;
11258 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11260 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11262 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11264 salt
->salt_len
= salt_len
;
11266 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11267 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11268 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11269 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11271 digest
[0] = byte_swap_32 (digest
[0]);
11272 digest
[1] = byte_swap_32 (digest
[1]);
11273 digest
[2] = byte_swap_32 (digest
[2]);
11274 digest
[3] = byte_swap_32 (digest
[3]);
11276 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11278 uint digest_tmp
[2] = { 0 };
11280 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11281 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11283 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11284 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11286 /* special case 2: ESS */
11288 if (srvchall_len
== 48)
11290 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11292 uint w
[16] = { 0 };
11294 w
[ 0] = netntlm
->chall_buf
[6];
11295 w
[ 1] = netntlm
->chall_buf
[7];
11296 w
[ 2] = netntlm
->chall_buf
[0];
11297 w
[ 3] = netntlm
->chall_buf
[1];
11301 uint dgst
[4] = { 0 };
11310 salt
->salt_buf
[0] = dgst
[0];
11311 salt
->salt_buf
[1] = dgst
[1];
11315 /* precompute netntlmv1 exploit start */
11317 for (uint i
= 0; i
< 0x10000; i
++)
11319 uint key_md4
[2] = { i
, 0 };
11320 uint key_des
[2] = { 0, 0 };
11322 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11324 uint Kc
[16] = { 0 };
11325 uint Kd
[16] = { 0 };
11327 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11329 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11331 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11333 if (data3
[0] != digest_tmp
[0]) continue;
11334 if (data3
[1] != digest_tmp
[1]) continue;
11336 salt
->salt_buf
[2] = i
;
11338 salt
->salt_len
= 24;
11343 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11344 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11346 /* precompute netntlmv1 exploit stop */
11350 IP (digest
[0], digest
[1], tt
);
11351 IP (digest
[2], digest
[3], tt
);
11353 digest
[0] = rotr32 (digest
[0], 29);
11354 digest
[1] = rotr32 (digest
[1], 29);
11355 digest
[2] = rotr32 (digest
[2], 29);
11356 digest
[3] = rotr32 (digest
[3], 29);
11358 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11360 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11361 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11363 return (PARSER_OK
);
11366 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11368 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11370 u32
*digest
= (u32
*) hash_buf
->digest
;
11372 salt_t
*salt
= hash_buf
->salt
;
11374 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11380 char *user_pos
= input_buf
;
11382 char *unused_pos
= strchr (user_pos
, ':');
11384 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11386 uint user_len
= unused_pos
- user_pos
;
11388 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11392 char *domain_pos
= strchr (unused_pos
, ':');
11394 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11396 uint unused_len
= domain_pos
- unused_pos
;
11398 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11402 char *srvchall_pos
= strchr (domain_pos
, ':');
11404 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11406 uint domain_len
= srvchall_pos
- domain_pos
;
11408 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11412 char *hash_pos
= strchr (srvchall_pos
, ':');
11414 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11416 uint srvchall_len
= hash_pos
- srvchall_pos
;
11418 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11422 char *clichall_pos
= strchr (hash_pos
, ':');
11424 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11426 uint hash_len
= clichall_pos
- hash_pos
;
11428 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11432 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11434 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11436 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11439 * store some data for later use
11442 netntlm
->user_len
= user_len
* 2;
11443 netntlm
->domain_len
= domain_len
* 2;
11444 netntlm
->srvchall_len
= srvchall_len
/ 2;
11445 netntlm
->clichall_len
= clichall_len
/ 2;
11447 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11448 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11451 * handle username and domainname
11454 for (uint i
= 0; i
< user_len
; i
++)
11456 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11457 *userdomain_ptr
++ = 0;
11460 for (uint i
= 0; i
< domain_len
; i
++)
11462 *userdomain_ptr
++ = domain_pos
[i
];
11463 *userdomain_ptr
++ = 0;
11466 *userdomain_ptr
++ = 0x80;
11469 * handle server challenge encoding
11472 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11474 const char p0
= srvchall_pos
[i
+ 0];
11475 const char p1
= srvchall_pos
[i
+ 1];
11477 *chall_ptr
++ = hex_convert (p1
) << 0
11478 | hex_convert (p0
) << 4;
11482 * handle client challenge encoding
11485 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11487 const char p0
= clichall_pos
[i
+ 0];
11488 const char p1
= clichall_pos
[i
+ 1];
11490 *chall_ptr
++ = hex_convert (p1
) << 0
11491 | hex_convert (p0
) << 4;
11494 *chall_ptr
++ = 0x80;
11497 * handle hash itself
11500 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11501 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11502 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11503 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11505 digest
[0] = byte_swap_32 (digest
[0]);
11506 digest
[1] = byte_swap_32 (digest
[1]);
11507 digest
[2] = byte_swap_32 (digest
[2]);
11508 digest
[3] = byte_swap_32 (digest
[3]);
11511 * reuse challange data as salt_buf, its the buffer that is most likely unique
11514 salt
->salt_buf
[0] = 0;
11515 salt
->salt_buf
[1] = 0;
11516 salt
->salt_buf
[2] = 0;
11517 salt
->salt_buf
[3] = 0;
11518 salt
->salt_buf
[4] = 0;
11519 salt
->salt_buf
[5] = 0;
11520 salt
->salt_buf
[6] = 0;
11521 salt
->salt_buf
[7] = 0;
11525 uptr
= (uint
*) netntlm
->userdomain_buf
;
11527 for (uint i
= 0; i
< 16; i
+= 16)
11529 md5_64 (uptr
, salt
->salt_buf
);
11532 uptr
= (uint
*) netntlm
->chall_buf
;
11534 for (uint i
= 0; i
< 256; i
+= 16)
11536 md5_64 (uptr
, salt
->salt_buf
);
11539 salt
->salt_len
= 16;
11541 return (PARSER_OK
);
11544 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11546 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11548 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11552 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11555 u32
*digest
= (u32
*) hash_buf
->digest
;
11557 salt_t
*salt
= hash_buf
->salt
;
11559 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11560 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11561 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11562 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11564 digest
[0] = byte_swap_32 (digest
[0]);
11565 digest
[1] = byte_swap_32 (digest
[1]);
11566 digest
[2] = byte_swap_32 (digest
[2]);
11567 digest
[3] = byte_swap_32 (digest
[3]);
11569 digest
[0] -= MD5M_A
;
11570 digest
[1] -= MD5M_B
;
11571 digest
[2] -= MD5M_C
;
11572 digest
[3] -= MD5M_D
;
11574 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11576 uint salt_len
= input_len
- 32 - 1;
11578 char *salt_buf
= input_buf
+ 32 + 1;
11580 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11582 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11584 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11586 salt
->salt_len
= salt_len
;
11588 return (PARSER_OK
);
11591 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11593 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11595 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11599 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11602 u32
*digest
= (u32
*) hash_buf
->digest
;
11604 salt_t
*salt
= hash_buf
->salt
;
11606 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11607 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11608 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11609 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11611 digest
[0] = byte_swap_32 (digest
[0]);
11612 digest
[1] = byte_swap_32 (digest
[1]);
11613 digest
[2] = byte_swap_32 (digest
[2]);
11614 digest
[3] = byte_swap_32 (digest
[3]);
11616 digest
[0] -= MD5M_A
;
11617 digest
[1] -= MD5M_B
;
11618 digest
[2] -= MD5M_C
;
11619 digest
[3] -= MD5M_D
;
11621 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11623 uint salt_len
= input_len
- 32 - 1;
11625 char *salt_buf
= input_buf
+ 32 + 1;
11627 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11629 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11631 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11633 salt
->salt_len
= salt_len
;
11635 return (PARSER_OK
);
11638 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11640 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11642 u32
*digest
= (u32
*) hash_buf
->digest
;
11644 salt_t
*salt
= hash_buf
->salt
;
11646 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11647 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11648 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11649 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11651 digest
[0] = byte_swap_32 (digest
[0]);
11652 digest
[1] = byte_swap_32 (digest
[1]);
11653 digest
[2] = byte_swap_32 (digest
[2]);
11654 digest
[3] = byte_swap_32 (digest
[3]);
11656 digest
[0] -= MD5M_A
;
11657 digest
[1] -= MD5M_B
;
11658 digest
[2] -= MD5M_C
;
11659 digest
[3] -= MD5M_D
;
11662 * This is a virtual salt. While the algorithm is basically not salted
11663 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11664 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11667 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11669 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11671 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11673 salt
->salt_len
= salt_len
;
11675 return (PARSER_OK
);
11678 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11680 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11682 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11686 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11689 u32
*digest
= (u32
*) hash_buf
->digest
;
11691 salt_t
*salt
= hash_buf
->salt
;
11693 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11694 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11695 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11696 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11698 digest
[0] = byte_swap_32 (digest
[0]);
11699 digest
[1] = byte_swap_32 (digest
[1]);
11700 digest
[2] = byte_swap_32 (digest
[2]);
11701 digest
[3] = byte_swap_32 (digest
[3]);
11703 digest
[0] -= MD5M_A
;
11704 digest
[1] -= MD5M_B
;
11705 digest
[2] -= MD5M_C
;
11706 digest
[3] -= MD5M_D
;
11708 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11710 uint salt_len
= input_len
- 32 - 1;
11712 char *salt_buf
= input_buf
+ 32 + 1;
11714 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11716 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11718 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11720 salt
->salt_len
= salt_len
;
11722 return (PARSER_OK
);
11725 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11727 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11729 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11733 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11736 u32
*digest
= (u32
*) hash_buf
->digest
;
11738 salt_t
*salt
= hash_buf
->salt
;
11740 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11741 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11742 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11743 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11745 digest
[0] = byte_swap_32 (digest
[0]);
11746 digest
[1] = byte_swap_32 (digest
[1]);
11747 digest
[2] = byte_swap_32 (digest
[2]);
11748 digest
[3] = byte_swap_32 (digest
[3]);
11750 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11752 uint salt_len
= input_len
- 32 - 1;
11754 char *salt_buf
= input_buf
+ 32 + 1;
11756 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11758 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11760 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11762 salt
->salt_len
= salt_len
;
11764 return (PARSER_OK
);
11767 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11769 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11771 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11775 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11778 u32
*digest
= (u32
*) hash_buf
->digest
;
11780 salt_t
*salt
= hash_buf
->salt
;
11782 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11783 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11784 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11785 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11787 digest
[0] = byte_swap_32 (digest
[0]);
11788 digest
[1] = byte_swap_32 (digest
[1]);
11789 digest
[2] = byte_swap_32 (digest
[2]);
11790 digest
[3] = byte_swap_32 (digest
[3]);
11792 digest
[0] -= MD4M_A
;
11793 digest
[1] -= MD4M_B
;
11794 digest
[2] -= MD4M_C
;
11795 digest
[3] -= MD4M_D
;
11797 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11799 uint salt_len
= input_len
- 32 - 1;
11801 char *salt_buf
= input_buf
+ 32 + 1;
11803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11805 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11807 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11809 salt
->salt_len
= salt_len
;
11811 return (PARSER_OK
);
11814 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11816 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11818 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11822 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11825 u32
*digest
= (u32
*) hash_buf
->digest
;
11827 salt_t
*salt
= hash_buf
->salt
;
11829 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11830 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11831 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11832 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11834 digest
[0] = byte_swap_32 (digest
[0]);
11835 digest
[1] = byte_swap_32 (digest
[1]);
11836 digest
[2] = byte_swap_32 (digest
[2]);
11837 digest
[3] = byte_swap_32 (digest
[3]);
11839 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11841 uint salt_len
= input_len
- 32 - 1;
11843 char *salt_buf
= input_buf
+ 32 + 1;
11845 uint salt_pc_block
[16] = { 0 };
11847 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11849 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11851 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11853 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11855 salt_pc_block
[14] = salt_len
* 8;
11857 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11859 md5_64 (salt_pc_block
, salt_pc_digest
);
11861 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11862 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11863 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11864 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11866 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11868 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11870 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11872 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11873 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11874 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11875 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11877 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11879 return (PARSER_OK
);
11882 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11884 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11886 u32
*digest
= (u32
*) hash_buf
->digest
;
11888 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11889 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11890 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11891 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11892 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11894 digest
[0] -= SHA1M_A
;
11895 digest
[1] -= SHA1M_B
;
11896 digest
[2] -= SHA1M_C
;
11897 digest
[3] -= SHA1M_D
;
11898 digest
[4] -= SHA1M_E
;
11900 return (PARSER_OK
);
11903 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11905 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11907 u32
*digest
= (u32
*) hash_buf
->digest
;
11909 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11910 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11911 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11912 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11913 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11915 return (PARSER_OK
);
11918 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11920 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11922 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11924 u32
*digest
= (u32
*) hash_buf
->digest
;
11928 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11929 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11930 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11931 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11932 digest
[4] = 0x00000000;
11934 return (PARSER_OK
);
11937 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11939 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11941 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11945 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11948 u32
*digest
= (u32
*) hash_buf
->digest
;
11950 salt_t
*salt
= hash_buf
->salt
;
11952 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11953 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11954 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11955 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11956 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11958 digest
[0] -= SHA1M_A
;
11959 digest
[1] -= SHA1M_B
;
11960 digest
[2] -= SHA1M_C
;
11961 digest
[3] -= SHA1M_D
;
11962 digest
[4] -= SHA1M_E
;
11964 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11966 uint salt_len
= input_len
- 40 - 1;
11968 char *salt_buf
= input_buf
+ 40 + 1;
11970 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11972 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11974 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11976 salt
->salt_len
= salt_len
;
11978 return (PARSER_OK
);
11981 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11983 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11985 u32
*digest
= (u32
*) hash_buf
->digest
;
11987 salt_t
*salt
= hash_buf
->salt
;
11989 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11991 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11992 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11993 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11994 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11995 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11997 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11999 uint salt_len
= input_len
- 40 - 1;
12001 char *salt_buf
= input_buf
+ 40 + 1;
12003 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12005 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12007 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12009 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12012 pstoken
->salt_len
= salt_len
/ 2;
12014 /* some fake salt for the sorting mechanisms */
12016 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12017 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12018 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12019 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12020 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12021 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12022 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12023 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12025 salt
->salt_len
= 32;
12027 /* we need to check if we can precompute some of the data --
12028 this is possible since the scheme is badly designed */
12030 pstoken
->pc_digest
[0] = SHA1M_A
;
12031 pstoken
->pc_digest
[1] = SHA1M_B
;
12032 pstoken
->pc_digest
[2] = SHA1M_C
;
12033 pstoken
->pc_digest
[3] = SHA1M_D
;
12034 pstoken
->pc_digest
[4] = SHA1M_E
;
12036 pstoken
->pc_offset
= 0;
12038 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12042 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12043 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12044 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12045 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12046 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12047 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12048 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12049 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12050 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12051 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12052 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12053 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12054 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12055 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12056 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12057 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12059 sha1_64 (w
, pstoken
->pc_digest
);
12061 pstoken
->pc_offset
+= 16;
12064 return (PARSER_OK
);
12067 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12069 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12071 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12073 u32
*digest
= (u32
*) hash_buf
->digest
;
12075 u8 tmp_buf
[100] = { 0 };
12077 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12079 memcpy (digest
, tmp_buf
, 20);
12081 digest
[0] = byte_swap_32 (digest
[0]);
12082 digest
[1] = byte_swap_32 (digest
[1]);
12083 digest
[2] = byte_swap_32 (digest
[2]);
12084 digest
[3] = byte_swap_32 (digest
[3]);
12085 digest
[4] = byte_swap_32 (digest
[4]);
12087 digest
[0] -= SHA1M_A
;
12088 digest
[1] -= SHA1M_B
;
12089 digest
[2] -= SHA1M_C
;
12090 digest
[3] -= SHA1M_D
;
12091 digest
[4] -= SHA1M_E
;
12093 return (PARSER_OK
);
12096 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12098 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12100 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12102 u32
*digest
= (u32
*) hash_buf
->digest
;
12104 salt_t
*salt
= hash_buf
->salt
;
12106 u8 tmp_buf
[100] = { 0 };
12108 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12110 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12112 memcpy (digest
, tmp_buf
, 20);
12114 int salt_len
= tmp_len
- 20;
12116 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12118 salt
->salt_len
= salt_len
;
12120 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12122 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12124 char *ptr
= (char *) salt
->salt_buf
;
12126 ptr
[salt
->salt_len
] = 0x80;
12129 digest
[0] = byte_swap_32 (digest
[0]);
12130 digest
[1] = byte_swap_32 (digest
[1]);
12131 digest
[2] = byte_swap_32 (digest
[2]);
12132 digest
[3] = byte_swap_32 (digest
[3]);
12133 digest
[4] = byte_swap_32 (digest
[4]);
12135 digest
[0] -= SHA1M_A
;
12136 digest
[1] -= SHA1M_B
;
12137 digest
[2] -= SHA1M_C
;
12138 digest
[3] -= SHA1M_D
;
12139 digest
[4] -= SHA1M_E
;
12141 return (PARSER_OK
);
12144 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12146 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12148 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12150 u32
*digest
= (u32
*) hash_buf
->digest
;
12152 salt_t
*salt
= hash_buf
->salt
;
12154 char *salt_buf
= input_buf
+ 6;
12158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12164 salt
->salt_len
= salt_len
;
12166 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12168 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12169 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12170 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12171 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12172 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12174 digest
[0] -= SHA1M_A
;
12175 digest
[1] -= SHA1M_B
;
12176 digest
[2] -= SHA1M_C
;
12177 digest
[3] -= SHA1M_D
;
12178 digest
[4] -= SHA1M_E
;
12180 return (PARSER_OK
);
12183 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12185 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12187 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12189 u32
*digest
= (u32
*) hash_buf
->digest
;
12191 salt_t
*salt
= hash_buf
->salt
;
12193 char *salt_buf
= input_buf
+ 6;
12197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12203 salt
->salt_len
= salt_len
;
12205 char *hash_pos
= input_buf
+ 6 + 8;
12207 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12208 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12209 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12210 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12211 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12213 digest
[0] -= SHA1M_A
;
12214 digest
[1] -= SHA1M_B
;
12215 digest
[2] -= SHA1M_C
;
12216 digest
[3] -= SHA1M_D
;
12217 digest
[4] -= SHA1M_E
;
12219 return (PARSER_OK
);
12222 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12224 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12226 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12228 u64
*digest
= (u64
*) hash_buf
->digest
;
12230 salt_t
*salt
= hash_buf
->salt
;
12232 char *salt_buf
= input_buf
+ 6;
12236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12242 salt
->salt_len
= salt_len
;
12244 char *hash_pos
= input_buf
+ 6 + 8;
12246 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12247 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12248 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12249 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12250 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12251 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12252 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12253 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12255 digest
[0] -= SHA512M_A
;
12256 digest
[1] -= SHA512M_B
;
12257 digest
[2] -= SHA512M_C
;
12258 digest
[3] -= SHA512M_D
;
12259 digest
[4] -= SHA512M_E
;
12260 digest
[5] -= SHA512M_F
;
12261 digest
[6] -= SHA512M_G
;
12262 digest
[7] -= SHA512M_H
;
12264 return (PARSER_OK
);
12267 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12269 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12271 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12275 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12278 u32
*digest
= (u32
*) hash_buf
->digest
;
12280 salt_t
*salt
= hash_buf
->salt
;
12282 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12283 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12287 digest
[0] = byte_swap_32 (digest
[0]);
12288 digest
[1] = byte_swap_32 (digest
[1]);
12290 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12292 uint salt_len
= input_len
- 16 - 1;
12294 char *salt_buf
= input_buf
+ 16 + 1;
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 return (PARSER_OK
);
12307 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12309 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12311 u32
*digest
= (u32
*) hash_buf
->digest
;
12313 salt_t
*salt
= hash_buf
->salt
;
12315 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12316 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12317 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12318 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12319 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12321 digest
[0] -= SHA1M_A
;
12322 digest
[1] -= SHA1M_B
;
12323 digest
[2] -= SHA1M_C
;
12324 digest
[3] -= SHA1M_D
;
12325 digest
[4] -= SHA1M_E
;
12327 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12329 uint salt_len
= input_len
- 40 - 1;
12331 char *salt_buf
= input_buf
+ 40 + 1;
12333 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12335 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12337 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12339 salt
->salt_len
= salt_len
;
12341 return (PARSER_OK
);
12344 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12346 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12348 u32
*digest
= (u32
*) hash_buf
->digest
;
12350 salt_t
*salt
= hash_buf
->salt
;
12352 char *hash_pos
= input_buf
;
12354 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12355 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12356 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12357 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12358 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12359 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12360 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12361 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12362 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12363 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12364 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12365 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12366 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12367 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12368 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12369 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12371 char *salt_pos
= input_buf
+ 128;
12373 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12374 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12375 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12376 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12378 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12379 salt
->salt_len
= 16;
12381 return (PARSER_OK
);
12384 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12386 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12388 u32
*digest
= (u32
*) hash_buf
->digest
;
12390 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12391 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12392 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12393 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12394 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12395 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12396 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12397 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12399 digest
[0] -= SHA256M_A
;
12400 digest
[1] -= SHA256M_B
;
12401 digest
[2] -= SHA256M_C
;
12402 digest
[3] -= SHA256M_D
;
12403 digest
[4] -= SHA256M_E
;
12404 digest
[5] -= SHA256M_F
;
12405 digest
[6] -= SHA256M_G
;
12406 digest
[7] -= SHA256M_H
;
12408 return (PARSER_OK
);
12411 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12413 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12415 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12419 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12422 u32
*digest
= (u32
*) hash_buf
->digest
;
12424 salt_t
*salt
= hash_buf
->salt
;
12426 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12427 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12428 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12429 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12430 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12431 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12432 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12433 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12435 digest
[0] -= SHA256M_A
;
12436 digest
[1] -= SHA256M_B
;
12437 digest
[2] -= SHA256M_C
;
12438 digest
[3] -= SHA256M_D
;
12439 digest
[4] -= SHA256M_E
;
12440 digest
[5] -= SHA256M_F
;
12441 digest
[6] -= SHA256M_G
;
12442 digest
[7] -= SHA256M_H
;
12444 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12446 uint salt_len
= input_len
- 64 - 1;
12448 char *salt_buf
= input_buf
+ 64 + 1;
12450 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12452 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12454 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12456 salt
->salt_len
= salt_len
;
12458 return (PARSER_OK
);
12461 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12463 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12465 u64
*digest
= (u64
*) hash_buf
->digest
;
12467 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12468 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12469 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12470 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12471 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12472 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12476 digest
[0] -= SHA384M_A
;
12477 digest
[1] -= SHA384M_B
;
12478 digest
[2] -= SHA384M_C
;
12479 digest
[3] -= SHA384M_D
;
12480 digest
[4] -= SHA384M_E
;
12481 digest
[5] -= SHA384M_F
;
12485 return (PARSER_OK
);
12488 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12490 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12492 u64
*digest
= (u64
*) hash_buf
->digest
;
12494 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12495 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12496 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12497 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12498 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12499 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12500 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12501 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12503 digest
[0] -= SHA512M_A
;
12504 digest
[1] -= SHA512M_B
;
12505 digest
[2] -= SHA512M_C
;
12506 digest
[3] -= SHA512M_D
;
12507 digest
[4] -= SHA512M_E
;
12508 digest
[5] -= SHA512M_F
;
12509 digest
[6] -= SHA512M_G
;
12510 digest
[7] -= SHA512M_H
;
12512 return (PARSER_OK
);
12515 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12517 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12519 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12523 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12526 u64
*digest
= (u64
*) hash_buf
->digest
;
12528 salt_t
*salt
= hash_buf
->salt
;
12530 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12531 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12532 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12533 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12534 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12535 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12536 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12537 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12539 digest
[0] -= SHA512M_A
;
12540 digest
[1] -= SHA512M_B
;
12541 digest
[2] -= SHA512M_C
;
12542 digest
[3] -= SHA512M_D
;
12543 digest
[4] -= SHA512M_E
;
12544 digest
[5] -= SHA512M_F
;
12545 digest
[6] -= SHA512M_G
;
12546 digest
[7] -= SHA512M_H
;
12548 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12550 uint salt_len
= input_len
- 128 - 1;
12552 char *salt_buf
= input_buf
+ 128 + 1;
12554 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12556 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12558 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12560 salt
->salt_len
= salt_len
;
12562 return (PARSER_OK
);
12565 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12567 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12569 u64
*digest
= (u64
*) hash_buf
->digest
;
12571 salt_t
*salt
= hash_buf
->salt
;
12573 char *salt_pos
= input_buf
+ 3;
12575 uint iterations_len
= 0;
12577 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12581 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12583 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12584 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12588 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12592 iterations_len
+= 8;
12596 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12599 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12601 char *hash_pos
= strchr (salt_pos
, '$');
12603 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12605 uint salt_len
= hash_pos
- salt_pos
;
12607 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12609 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12611 salt
->salt_len
= salt_len
;
12615 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12617 return (PARSER_OK
);
12620 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12622 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12624 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12626 u64
*digest
= (u64
*) hash_buf
->digest
;
12628 salt_t
*salt
= hash_buf
->salt
;
12630 uint keccak_mdlen
= input_len
/ 2;
12632 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12634 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12636 digest
[i
] = byte_swap_64 (digest
[i
]);
12639 salt
->keccak_mdlen
= keccak_mdlen
;
12641 return (PARSER_OK
);
12644 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12646 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12648 u32
*digest
= (u32
*) hash_buf
->digest
;
12650 salt_t
*salt
= hash_buf
->salt
;
12652 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12655 * Parse that strange long line
12660 size_t in_len
[9] = { 0 };
12662 in_off
[0] = strtok (input_buf
, ":");
12664 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12666 in_len
[0] = strlen (in_off
[0]);
12670 for (i
= 1; i
< 9; i
++)
12672 in_off
[i
] = strtok (NULL
, ":");
12674 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12676 in_len
[i
] = strlen (in_off
[i
]);
12679 char *ptr
= (char *) ikepsk
->msg_buf
;
12681 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12682 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12683 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12684 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12685 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12686 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12690 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12692 ptr
= (char *) ikepsk
->nr_buf
;
12694 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12695 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12699 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12702 * Store to database
12707 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12708 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12709 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12710 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12712 digest
[0] = byte_swap_32 (digest
[0]);
12713 digest
[1] = byte_swap_32 (digest
[1]);
12714 digest
[2] = byte_swap_32 (digest
[2]);
12715 digest
[3] = byte_swap_32 (digest
[3]);
12717 salt
->salt_len
= 32;
12719 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12720 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12721 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12722 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12723 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12724 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12725 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12726 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12728 return (PARSER_OK
);
12731 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12733 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12735 u32
*digest
= (u32
*) hash_buf
->digest
;
12737 salt_t
*salt
= hash_buf
->salt
;
12739 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12742 * Parse that strange long line
12747 size_t in_len
[9] = { 0 };
12749 in_off
[0] = strtok (input_buf
, ":");
12751 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12753 in_len
[0] = strlen (in_off
[0]);
12757 for (i
= 1; i
< 9; i
++)
12759 in_off
[i
] = strtok (NULL
, ":");
12761 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12763 in_len
[i
] = strlen (in_off
[i
]);
12766 char *ptr
= (char *) ikepsk
->msg_buf
;
12768 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12769 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12770 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12771 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12772 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12773 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12777 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12779 ptr
= (char *) ikepsk
->nr_buf
;
12781 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12782 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12786 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12789 * Store to database
12794 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12795 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12796 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12797 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12798 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12800 salt
->salt_len
= 32;
12802 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12803 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12804 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12805 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12806 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12807 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12808 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12809 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12811 return (PARSER_OK
);
12814 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12816 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12818 u32
*digest
= (u32
*) hash_buf
->digest
;
12820 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12821 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12822 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12823 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12824 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12826 digest
[0] = byte_swap_32 (digest
[0]);
12827 digest
[1] = byte_swap_32 (digest
[1]);
12828 digest
[2] = byte_swap_32 (digest
[2]);
12829 digest
[3] = byte_swap_32 (digest
[3]);
12830 digest
[4] = byte_swap_32 (digest
[4]);
12832 return (PARSER_OK
);
12835 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12837 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12839 u32
*digest
= (u32
*) hash_buf
->digest
;
12841 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12842 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12843 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12844 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12845 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12846 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12847 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12848 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12849 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12850 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12851 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12852 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12853 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12854 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12855 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12856 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12858 return (PARSER_OK
);
12861 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12863 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12865 u32
*digest
= (u32
*) hash_buf
->digest
;
12867 salt_t
*salt
= hash_buf
->salt
;
12869 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12870 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12871 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12872 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12873 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12875 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12877 uint salt_len
= input_len
- 40 - 1;
12879 char *salt_buf
= input_buf
+ 40 + 1;
12881 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12883 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12885 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12887 salt
->salt_len
= salt_len
;
12889 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12891 return (PARSER_OK
);
12894 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12896 u32
*digest
= (u32
*) hash_buf
->digest
;
12898 salt_t
*salt
= hash_buf
->salt
;
12900 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12902 if (input_len
== 0)
12904 log_error ("TrueCrypt container not specified");
12909 FILE *fp
= fopen (input_buf
, "rb");
12913 log_error ("%s: %s", input_buf
, strerror (errno
));
12918 char buf
[512] = { 0 };
12920 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12924 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12926 memcpy (tc
->salt_buf
, buf
, 64);
12928 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12930 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12932 salt
->salt_len
= 4;
12934 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12936 tc
->signature
= 0x45555254; // "TRUE"
12938 digest
[0] = tc
->data_buf
[0];
12940 return (PARSER_OK
);
12943 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12945 u32
*digest
= (u32
*) hash_buf
->digest
;
12947 salt_t
*salt
= hash_buf
->salt
;
12949 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12951 if (input_len
== 0)
12953 log_error ("TrueCrypt container not specified");
12958 FILE *fp
= fopen (input_buf
, "rb");
12962 log_error ("%s: %s", input_buf
, strerror (errno
));
12967 char buf
[512] = { 0 };
12969 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12973 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12975 memcpy (tc
->salt_buf
, buf
, 64);
12977 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12979 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12981 salt
->salt_len
= 4;
12983 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
12985 tc
->signature
= 0x45555254; // "TRUE"
12987 digest
[0] = tc
->data_buf
[0];
12989 return (PARSER_OK
);
12992 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12994 u32
*digest
= (u32
*) hash_buf
->digest
;
12996 salt_t
*salt
= hash_buf
->salt
;
12998 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13000 if (input_len
== 0)
13002 log_error ("VeraCrypt container not specified");
13007 FILE *fp
= fopen (input_buf
, "rb");
13011 log_error ("%s: %s", input_buf
, strerror (errno
));
13016 char buf
[512] = { 0 };
13018 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13022 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13024 memcpy (tc
->salt_buf
, buf
, 64);
13026 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13028 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13030 salt
->salt_len
= 4;
13032 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13034 tc
->signature
= 0x41524556; // "VERA"
13036 digest
[0] = tc
->data_buf
[0];
13038 return (PARSER_OK
);
13041 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13043 u32
*digest
= (u32
*) hash_buf
->digest
;
13045 salt_t
*salt
= hash_buf
->salt
;
13047 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13049 if (input_len
== 0)
13051 log_error ("VeraCrypt container not specified");
13056 FILE *fp
= fopen (input_buf
, "rb");
13060 log_error ("%s: %s", input_buf
, strerror (errno
));
13065 char buf
[512] = { 0 };
13067 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13071 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13073 memcpy (tc
->salt_buf
, buf
, 64);
13075 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13077 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13079 salt
->salt_len
= 4;
13081 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13083 tc
->signature
= 0x41524556; // "VERA"
13085 digest
[0] = tc
->data_buf
[0];
13087 return (PARSER_OK
);
13090 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13092 u32
*digest
= (u32
*) hash_buf
->digest
;
13094 salt_t
*salt
= hash_buf
->salt
;
13096 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13098 if (input_len
== 0)
13100 log_error ("VeraCrypt container not specified");
13105 FILE *fp
= fopen (input_buf
, "rb");
13109 log_error ("%s: %s", input_buf
, strerror (errno
));
13114 char buf
[512] = { 0 };
13116 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13120 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13122 memcpy (tc
->salt_buf
, buf
, 64);
13124 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13126 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13128 salt
->salt_len
= 4;
13130 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13132 tc
->signature
= 0x41524556; // "VERA"
13134 digest
[0] = tc
->data_buf
[0];
13136 return (PARSER_OK
);
13139 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13141 u32
*digest
= (u32
*) hash_buf
->digest
;
13143 salt_t
*salt
= hash_buf
->salt
;
13145 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13147 if (input_len
== 0)
13149 log_error ("VeraCrypt container not specified");
13154 FILE *fp
= fopen (input_buf
, "rb");
13158 log_error ("%s: %s", input_buf
, strerror (errno
));
13163 char buf
[512] = { 0 };
13165 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13169 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13171 memcpy (tc
->salt_buf
, buf
, 64);
13173 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13175 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13177 salt
->salt_len
= 4;
13179 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13181 tc
->signature
= 0x41524556; // "VERA"
13183 digest
[0] = tc
->data_buf
[0];
13185 return (PARSER_OK
);
13188 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13190 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13192 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13194 u32
*digest
= (u32
*) hash_buf
->digest
;
13196 salt_t
*salt
= hash_buf
->salt
;
13198 char *salt_pos
= input_buf
+ 6;
13200 char *hash_pos
= strchr (salt_pos
, '$');
13202 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13204 uint salt_len
= hash_pos
- salt_pos
;
13206 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13208 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13210 salt
->salt_len
= salt_len
;
13212 salt
->salt_iter
= 1000;
13216 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13218 return (PARSER_OK
);
13221 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13223 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13225 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13227 u32
*digest
= (u32
*) hash_buf
->digest
;
13229 salt_t
*salt
= hash_buf
->salt
;
13231 char *iter_pos
= input_buf
+ 7;
13233 char *salt_pos
= strchr (iter_pos
, '$');
13235 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13239 char *hash_pos
= strchr (salt_pos
, '$');
13241 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13243 uint salt_len
= hash_pos
- salt_pos
;
13245 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13247 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13249 salt
->salt_len
= salt_len
;
13251 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13253 salt
->salt_sign
[0] = atoi (salt_iter
);
13255 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13259 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13261 digest
[0] = byte_swap_32 (digest
[0]);
13262 digest
[1] = byte_swap_32 (digest
[1]);
13263 digest
[2] = byte_swap_32 (digest
[2]);
13264 digest
[3] = byte_swap_32 (digest
[3]);
13265 digest
[4] = byte_swap_32 (digest
[4]);
13267 return (PARSER_OK
);
13270 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13272 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13274 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13276 u32
*digest
= (u32
*) hash_buf
->digest
;
13278 salt_t
*salt
= hash_buf
->salt
;
13280 char *iter_pos
= input_buf
+ 9;
13282 char *salt_pos
= strchr (iter_pos
, '$');
13284 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13288 char *hash_pos
= strchr (salt_pos
, '$');
13290 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13292 uint salt_len
= hash_pos
- salt_pos
;
13294 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13296 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13298 salt
->salt_len
= salt_len
;
13300 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13302 salt
->salt_sign
[0] = atoi (salt_iter
);
13304 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13308 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13310 digest
[0] = byte_swap_32 (digest
[0]);
13311 digest
[1] = byte_swap_32 (digest
[1]);
13312 digest
[2] = byte_swap_32 (digest
[2]);
13313 digest
[3] = byte_swap_32 (digest
[3]);
13314 digest
[4] = byte_swap_32 (digest
[4]);
13315 digest
[5] = byte_swap_32 (digest
[5]);
13316 digest
[6] = byte_swap_32 (digest
[6]);
13317 digest
[7] = byte_swap_32 (digest
[7]);
13319 return (PARSER_OK
);
13322 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13324 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13326 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13328 u64
*digest
= (u64
*) hash_buf
->digest
;
13330 salt_t
*salt
= hash_buf
->salt
;
13332 char *iter_pos
= input_buf
+ 9;
13334 char *salt_pos
= strchr (iter_pos
, '$');
13336 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13340 char *hash_pos
= strchr (salt_pos
, '$');
13342 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13344 uint salt_len
= hash_pos
- salt_pos
;
13346 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13348 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13350 salt
->salt_len
= salt_len
;
13352 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13354 salt
->salt_sign
[0] = atoi (salt_iter
);
13356 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13360 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13362 digest
[0] = byte_swap_64 (digest
[0]);
13363 digest
[1] = byte_swap_64 (digest
[1]);
13364 digest
[2] = byte_swap_64 (digest
[2]);
13365 digest
[3] = byte_swap_64 (digest
[3]);
13366 digest
[4] = byte_swap_64 (digest
[4]);
13367 digest
[5] = byte_swap_64 (digest
[5]);
13368 digest
[6] = byte_swap_64 (digest
[6]);
13369 digest
[7] = byte_swap_64 (digest
[7]);
13371 return (PARSER_OK
);
13374 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13376 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13378 u32
*digest
= (u32
*) hash_buf
->digest
;
13380 salt_t
*salt
= hash_buf
->salt
;
13382 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13388 char *iterations_pos
= input_buf
;
13390 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13392 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13394 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13396 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13400 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13402 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13404 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13406 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13408 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13410 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13415 * pbkdf2 iterations
13418 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13421 * handle salt encoding
13424 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13426 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13428 const char p0
= saltbuf_pos
[i
+ 0];
13429 const char p1
= saltbuf_pos
[i
+ 1];
13431 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13432 | hex_convert (p0
) << 4;
13435 salt
->salt_len
= saltbuf_len
/ 2;
13438 * handle cipher encoding
13441 uint
*tmp
= (uint
*) mymalloc (32);
13443 char *cipherbuf_ptr
= (char *) tmp
;
13445 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13447 const char p0
= cipherbuf_pos
[i
+ 0];
13448 const char p1
= cipherbuf_pos
[i
+ 1];
13450 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13451 | hex_convert (p0
) << 4;
13454 // iv is stored at salt_buf 4 (length 16)
13455 // data is stored at salt_buf 8 (length 16)
13457 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13458 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13459 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13460 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13462 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13463 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13464 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13465 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13469 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13471 const char p0
= cipherbuf_pos
[j
+ 0];
13472 const char p1
= cipherbuf_pos
[j
+ 1];
13474 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13475 | hex_convert (p0
) << 4;
13482 digest
[0] = 0x10101010;
13483 digest
[1] = 0x10101010;
13484 digest
[2] = 0x10101010;
13485 digest
[3] = 0x10101010;
13487 return (PARSER_OK
);
13490 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13492 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13494 u32
*digest
= (u32
*) hash_buf
->digest
;
13496 salt_t
*salt
= hash_buf
->salt
;
13498 char *hashbuf_pos
= input_buf
;
13500 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13502 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13504 uint hash_len
= iterations_pos
- hashbuf_pos
;
13506 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13510 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13512 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13514 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13518 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13520 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13522 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13524 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13526 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13528 salt
->salt_len
= salt_len
;
13530 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13532 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13533 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13534 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13535 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13537 return (PARSER_OK
);
13540 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13542 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13544 u32
*digest
= (u32
*) hash_buf
->digest
;
13546 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13547 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13548 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13549 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13550 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13551 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13552 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13553 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13555 digest
[0] = byte_swap_32 (digest
[0]);
13556 digest
[1] = byte_swap_32 (digest
[1]);
13557 digest
[2] = byte_swap_32 (digest
[2]);
13558 digest
[3] = byte_swap_32 (digest
[3]);
13559 digest
[4] = byte_swap_32 (digest
[4]);
13560 digest
[5] = byte_swap_32 (digest
[5]);
13561 digest
[6] = byte_swap_32 (digest
[6]);
13562 digest
[7] = byte_swap_32 (digest
[7]);
13564 return (PARSER_OK
);
13567 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13569 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13571 u32
*digest
= (u32
*) hash_buf
->digest
;
13573 salt_t
*salt
= hash_buf
->salt
;
13575 char *salt_pos
= input_buf
+ 3;
13577 uint iterations_len
= 0;
13579 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13583 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13585 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13586 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13590 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13594 iterations_len
+= 8;
13598 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13601 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13603 char *hash_pos
= strchr (salt_pos
, '$');
13605 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13607 uint salt_len
= hash_pos
- salt_pos
;
13609 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13611 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13613 salt
->salt_len
= salt_len
;
13617 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13619 return (PARSER_OK
);
13622 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13624 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13626 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13628 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13630 u64
*digest
= (u64
*) hash_buf
->digest
;
13632 salt_t
*salt
= hash_buf
->salt
;
13634 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13636 char *iter_pos
= input_buf
+ 4;
13638 char *salt_pos
= strchr (iter_pos
, '$');
13640 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13644 char *hash_pos
= strchr (salt_pos
, '$');
13646 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13648 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13652 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13653 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13654 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13655 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13656 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13657 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13658 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13659 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13661 uint salt_len
= hash_pos
- salt_pos
- 1;
13663 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13665 salt
->salt_len
= salt_len
/ 2;
13667 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13668 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13669 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13670 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13671 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13672 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13673 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13674 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13676 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13677 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13678 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13679 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13680 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13681 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13682 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13683 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13684 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13685 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13687 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13689 salt
->salt_iter
= atoi (iter_pos
) - 1;
13691 return (PARSER_OK
);
13694 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13696 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13698 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13700 u32
*digest
= (u32
*) hash_buf
->digest
;
13702 salt_t
*salt
= hash_buf
->salt
;
13704 char *salt_pos
= input_buf
+ 14;
13706 char *hash_pos
= strchr (salt_pos
, '*');
13708 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13712 uint salt_len
= hash_pos
- salt_pos
- 1;
13714 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13716 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13718 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13720 salt
->salt_len
= salt_len
;
13722 u8 tmp_buf
[100] = { 0 };
13724 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13726 memcpy (digest
, tmp_buf
, 32);
13728 digest
[0] = byte_swap_32 (digest
[0]);
13729 digest
[1] = byte_swap_32 (digest
[1]);
13730 digest
[2] = byte_swap_32 (digest
[2]);
13731 digest
[3] = byte_swap_32 (digest
[3]);
13732 digest
[4] = byte_swap_32 (digest
[4]);
13733 digest
[5] = byte_swap_32 (digest
[5]);
13734 digest
[6] = byte_swap_32 (digest
[6]);
13735 digest
[7] = byte_swap_32 (digest
[7]);
13737 digest
[0] -= SHA256M_A
;
13738 digest
[1] -= SHA256M_B
;
13739 digest
[2] -= SHA256M_C
;
13740 digest
[3] -= SHA256M_D
;
13741 digest
[4] -= SHA256M_E
;
13742 digest
[5] -= SHA256M_F
;
13743 digest
[6] -= SHA256M_G
;
13744 digest
[7] -= SHA256M_H
;
13746 return (PARSER_OK
);
13749 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13751 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13753 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13755 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13757 u64
*digest
= (u64
*) hash_buf
->digest
;
13759 salt_t
*salt
= hash_buf
->salt
;
13761 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13763 char *iter_pos
= input_buf
+ 19;
13765 char *salt_pos
= strchr (iter_pos
, '.');
13767 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13771 char *hash_pos
= strchr (salt_pos
, '.');
13773 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13775 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13779 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13780 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13781 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13782 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13783 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13784 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13785 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13786 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13788 uint salt_len
= hash_pos
- salt_pos
- 1;
13792 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13796 for (i
= 0; i
< salt_len
; i
++)
13798 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13801 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13802 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13804 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13806 salt
->salt_len
= salt_len
;
13808 salt
->salt_iter
= atoi (iter_pos
) - 1;
13810 return (PARSER_OK
);
13813 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13815 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13817 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13819 u64
*digest
= (u64
*) hash_buf
->digest
;
13821 salt_t
*salt
= hash_buf
->salt
;
13823 u8 tmp_buf
[120] = { 0 };
13825 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13827 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13829 memcpy (digest
, tmp_buf
, 64);
13831 digest
[0] = byte_swap_64 (digest
[0]);
13832 digest
[1] = byte_swap_64 (digest
[1]);
13833 digest
[2] = byte_swap_64 (digest
[2]);
13834 digest
[3] = byte_swap_64 (digest
[3]);
13835 digest
[4] = byte_swap_64 (digest
[4]);
13836 digest
[5] = byte_swap_64 (digest
[5]);
13837 digest
[6] = byte_swap_64 (digest
[6]);
13838 digest
[7] = byte_swap_64 (digest
[7]);
13840 digest
[0] -= SHA512M_A
;
13841 digest
[1] -= SHA512M_B
;
13842 digest
[2] -= SHA512M_C
;
13843 digest
[3] -= SHA512M_D
;
13844 digest
[4] -= SHA512M_E
;
13845 digest
[5] -= SHA512M_F
;
13846 digest
[6] -= SHA512M_G
;
13847 digest
[7] -= SHA512M_H
;
13849 int salt_len
= tmp_len
- 64;
13851 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13853 salt
->salt_len
= salt_len
;
13855 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13857 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13859 char *ptr
= (char *) salt
->salt_buf
;
13861 ptr
[salt
->salt_len
] = 0x80;
13864 return (PARSER_OK
);
13867 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13869 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13871 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13875 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13878 u32
*digest
= (u32
*) hash_buf
->digest
;
13880 salt_t
*salt
= hash_buf
->salt
;
13882 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13883 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13884 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13885 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13887 digest
[0] = byte_swap_32 (digest
[0]);
13888 digest
[1] = byte_swap_32 (digest
[1]);
13889 digest
[2] = byte_swap_32 (digest
[2]);
13890 digest
[3] = byte_swap_32 (digest
[3]);
13892 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13894 uint salt_len
= input_len
- 32 - 1;
13896 char *salt_buf
= input_buf
+ 32 + 1;
13898 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13900 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13902 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13904 salt
->salt_len
= salt_len
;
13906 return (PARSER_OK
);
13909 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13911 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13913 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13917 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13920 u32
*digest
= (u32
*) hash_buf
->digest
;
13922 salt_t
*salt
= hash_buf
->salt
;
13924 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13925 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13926 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13927 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13928 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13930 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13932 uint salt_len
= input_len
- 40 - 1;
13934 char *salt_buf
= input_buf
+ 40 + 1;
13936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13938 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13942 salt
->salt_len
= salt_len
;
13944 return (PARSER_OK
);
13947 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13949 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13951 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13955 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13958 u32
*digest
= (u32
*) hash_buf
->digest
;
13960 salt_t
*salt
= hash_buf
->salt
;
13962 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13963 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13964 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13965 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13966 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13967 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13968 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13969 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13971 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13973 uint salt_len
= input_len
- 64 - 1;
13975 char *salt_buf
= input_buf
+ 64 + 1;
13977 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13979 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13981 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13983 salt
->salt_len
= salt_len
;
13985 return (PARSER_OK
);
13988 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13990 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13992 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13996 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13999 u64
*digest
= (u64
*) hash_buf
->digest
;
14001 salt_t
*salt
= hash_buf
->salt
;
14003 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14004 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14005 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14006 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14007 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14008 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14009 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14010 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14012 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14014 uint salt_len
= input_len
- 128 - 1;
14016 char *salt_buf
= input_buf
+ 128 + 1;
14018 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14020 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14022 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14024 salt
->salt_len
= salt_len
;
14026 return (PARSER_OK
);
14029 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14031 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14033 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14035 u32
*digest
= (u32
*) hash_buf
->digest
;
14037 salt_t
*salt
= hash_buf
->salt
;
14039 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14045 char *user_pos
= input_buf
+ 10 + 1;
14047 char *realm_pos
= strchr (user_pos
, '$');
14049 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14051 uint user_len
= realm_pos
- user_pos
;
14053 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14057 char *salt_pos
= strchr (realm_pos
, '$');
14059 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14061 uint realm_len
= salt_pos
- realm_pos
;
14063 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14067 char *data_pos
= strchr (salt_pos
, '$');
14069 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14071 uint salt_len
= data_pos
- salt_pos
;
14073 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14077 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14079 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14085 memcpy (krb5pa
->user
, user_pos
, user_len
);
14086 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14087 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14089 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14091 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14093 const char p0
= data_pos
[i
+ 0];
14094 const char p1
= data_pos
[i
+ 1];
14096 *timestamp_ptr
++ = hex_convert (p1
) << 0
14097 | hex_convert (p0
) << 4;
14100 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14102 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14104 const char p0
= data_pos
[i
+ 0];
14105 const char p1
= data_pos
[i
+ 1];
14107 *checksum_ptr
++ = hex_convert (p1
) << 0
14108 | hex_convert (p0
) << 4;
14112 * copy some data to generic buffers to make sorting happy
14115 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14116 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14117 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14118 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14119 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14120 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14121 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14122 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14123 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14125 salt
->salt_len
= 36;
14127 digest
[0] = krb5pa
->checksum
[0];
14128 digest
[1] = krb5pa
->checksum
[1];
14129 digest
[2] = krb5pa
->checksum
[2];
14130 digest
[3] = krb5pa
->checksum
[3];
14132 return (PARSER_OK
);
14135 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14137 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14139 u32
*digest
= (u32
*) hash_buf
->digest
;
14141 salt_t
*salt
= hash_buf
->salt
;
14147 char *salt_pos
= input_buf
;
14149 char *hash_pos
= strchr (salt_pos
, '$');
14151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14153 uint salt_len
= hash_pos
- salt_pos
;
14155 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14159 uint hash_len
= input_len
- 1 - salt_len
;
14161 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14169 for (uint i
= 0; i
< salt_len
; i
++)
14171 if (salt_pos
[i
] == ' ') continue;
14176 // SAP user names cannot be longer than 12 characters
14177 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14179 // SAP user name cannot start with ! or ?
14180 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14186 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14188 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14192 salt
->salt_len
= salt_len
;
14194 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14195 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14199 digest
[0] = byte_swap_32 (digest
[0]);
14200 digest
[1] = byte_swap_32 (digest
[1]);
14202 return (PARSER_OK
);
14205 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14207 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14209 u32
*digest
= (u32
*) hash_buf
->digest
;
14211 salt_t
*salt
= hash_buf
->salt
;
14217 char *salt_pos
= input_buf
;
14219 char *hash_pos
= strchr (salt_pos
, '$');
14221 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14223 uint salt_len
= hash_pos
- salt_pos
;
14225 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14229 uint hash_len
= input_len
- 1 - salt_len
;
14231 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14239 for (uint i
= 0; i
< salt_len
; i
++)
14241 if (salt_pos
[i
] == ' ') continue;
14246 // SAP user names cannot be longer than 12 characters
14247 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14248 // so far nobody complained so we stay with this because it helps in optimization
14249 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14251 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14253 // SAP user name cannot start with ! or ?
14254 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14260 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14262 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14264 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14266 salt
->salt_len
= salt_len
;
14268 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14269 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14270 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14271 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14272 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14274 return (PARSER_OK
);
14277 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14279 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14281 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14283 u64
*digest
= (u64
*) hash_buf
->digest
;
14285 salt_t
*salt
= hash_buf
->salt
;
14287 char *iter_pos
= input_buf
+ 3;
14289 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14291 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14293 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14295 salt
->salt_iter
= salt_iter
;
14297 char *salt_pos
= iter_pos
+ 1;
14301 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14303 salt
->salt_len
= salt_len
;
14305 char *hash_pos
= salt_pos
+ salt_len
;
14307 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14311 char *tmp
= (char *) salt
->salt_buf_pc
;
14313 tmp
[0] = hash_pos
[42];
14317 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14318 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14319 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14320 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14326 return (PARSER_OK
);
14329 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14331 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14333 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14335 u32
*digest
= (u32
*) hash_buf
->digest
;
14337 salt_t
*salt
= hash_buf
->salt
;
14339 char *salt_buf
= input_buf
+ 6;
14341 uint salt_len
= 16;
14343 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14349 salt
->salt_len
= salt_len
;
14351 char *hash_pos
= input_buf
+ 6 + 16;
14353 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14354 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14355 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14356 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14357 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14358 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14359 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14360 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14362 return (PARSER_OK
);
14365 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14367 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14369 u32
*digest
= (u32
*) hash_buf
->digest
;
14371 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14372 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14376 return (PARSER_OK
);
14379 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14381 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14383 u32
*digest
= (u32
*) hash_buf
->digest
;
14385 salt_t
*salt
= hash_buf
->salt
;
14387 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14389 char *saltbuf_pos
= input_buf
;
14391 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14393 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14395 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14397 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14398 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14400 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14404 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14406 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14408 char *salt_ptr
= (char *) saltbuf_pos
;
14409 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14414 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14416 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14419 rakp_ptr
[j
] = 0x80;
14421 rakp
->salt_len
= j
;
14423 for (i
= 0; i
< 64; i
++)
14425 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14428 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14429 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14430 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14431 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14432 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14433 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14434 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14435 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14437 salt
->salt_len
= 32; // muss min. 32 haben
14439 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14440 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14441 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14442 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14443 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14445 return (PARSER_OK
);
14448 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14450 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14452 u32
*digest
= (u32
*) hash_buf
->digest
;
14454 salt_t
*salt
= hash_buf
->salt
;
14456 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14458 char *salt_pos
= input_buf
+ 1;
14460 memcpy (salt
->salt_buf
, salt_pos
, 8);
14462 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14463 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14465 salt
->salt_len
= 8;
14467 char *hash_pos
= salt_pos
+ 8;
14469 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14470 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14471 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14472 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14473 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14475 digest
[0] -= SHA1M_A
;
14476 digest
[1] -= SHA1M_B
;
14477 digest
[2] -= SHA1M_C
;
14478 digest
[3] -= SHA1M_D
;
14479 digest
[4] -= SHA1M_E
;
14481 return (PARSER_OK
);
14484 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14486 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14488 u32
*digest
= (u32
*) hash_buf
->digest
;
14490 salt_t
*salt
= hash_buf
->salt
;
14492 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14493 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14494 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14495 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14497 digest
[0] = byte_swap_32 (digest
[0]);
14498 digest
[1] = byte_swap_32 (digest
[1]);
14499 digest
[2] = byte_swap_32 (digest
[2]);
14500 digest
[3] = byte_swap_32 (digest
[3]);
14502 digest
[0] -= MD5M_A
;
14503 digest
[1] -= MD5M_B
;
14504 digest
[2] -= MD5M_C
;
14505 digest
[3] -= MD5M_D
;
14507 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14509 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14511 u32
*salt_buf
= salt
->salt_buf
;
14513 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14514 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14515 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14516 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14518 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14519 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14520 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14521 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14523 salt
->salt_len
= 16 + 1;
14525 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14527 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14529 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14531 return (PARSER_OK
);
14534 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14536 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14538 u32
*digest
= (u32
*) hash_buf
->digest
;
14540 salt_t
*salt
= hash_buf
->salt
;
14542 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14548 char *hashbuf_pos
= input_buf
;
14550 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14552 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14554 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14556 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14560 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14562 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14564 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14566 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14570 char *databuf_pos
= strchr (iteration_pos
, ':');
14572 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14574 const uint iteration_len
= databuf_pos
- iteration_pos
;
14576 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14577 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14579 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14581 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14582 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14588 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14589 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14590 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14591 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14592 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14593 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14594 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14595 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14599 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14601 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14603 const char p0
= saltbuf_pos
[i
+ 0];
14604 const char p1
= saltbuf_pos
[i
+ 1];
14606 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14607 | hex_convert (p0
) << 4;
14610 salt
->salt_buf
[4] = 0x01000000;
14611 salt
->salt_buf
[5] = 0x80;
14613 salt
->salt_len
= saltbuf_len
/ 2;
14617 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14621 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14623 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14625 const char p0
= databuf_pos
[i
+ 0];
14626 const char p1
= databuf_pos
[i
+ 1];
14628 *databuf_ptr
++ = hex_convert (p1
) << 0
14629 | hex_convert (p0
) << 4;
14632 *databuf_ptr
++ = 0x80;
14634 for (uint i
= 0; i
< 512; i
++)
14636 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14639 cloudkey
->data_len
= databuf_len
/ 2;
14641 return (PARSER_OK
);
14644 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14646 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14648 u32
*digest
= (u32
*) hash_buf
->digest
;
14650 salt_t
*salt
= hash_buf
->salt
;
14656 char *hashbuf_pos
= input_buf
;
14658 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14660 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14662 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14664 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14668 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14670 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14672 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14674 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14676 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14680 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14682 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14684 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14686 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14688 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14692 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14694 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14695 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14697 // ok, the plan for this algorithm is the following:
14698 // we have 2 salts here, the domain-name and a random salt
14699 // while both are used in the initial transformation,
14700 // only the random salt is used in the following iterations
14701 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14702 // and one that includes only the real salt (stored into salt_buf[]).
14703 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14705 u8 tmp_buf
[100] = { 0 };
14707 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14709 memcpy (digest
, tmp_buf
, 20);
14711 digest
[0] = byte_swap_32 (digest
[0]);
14712 digest
[1] = byte_swap_32 (digest
[1]);
14713 digest
[2] = byte_swap_32 (digest
[2]);
14714 digest
[3] = byte_swap_32 (digest
[3]);
14715 digest
[4] = byte_swap_32 (digest
[4]);
14719 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14721 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14723 char *len_ptr
= NULL
;
14725 for (uint i
= 0; i
< domainbuf_len
; i
++)
14727 if (salt_buf_pc_ptr
[i
] == '.')
14729 len_ptr
= &salt_buf_pc_ptr
[i
];
14739 salt
->salt_buf_pc
[7] = domainbuf_len
;
14743 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14745 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14747 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14749 salt
->salt_len
= salt_len
;
14753 salt
->salt_iter
= atoi (iteration_pos
);
14755 return (PARSER_OK
);
14758 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14760 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14762 u32
*digest
= (u32
*) hash_buf
->digest
;
14764 salt_t
*salt
= hash_buf
->salt
;
14766 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14767 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14768 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14769 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14770 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14772 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14774 uint salt_len
= input_len
- 40 - 1;
14776 char *salt_buf
= input_buf
+ 40 + 1;
14778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14780 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14782 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14784 salt
->salt_len
= salt_len
;
14786 return (PARSER_OK
);
14789 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14791 const u8 ascii_to_ebcdic
[] =
14793 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14794 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14795 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14796 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14797 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14798 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14799 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14800 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14801 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14802 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14803 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14804 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14805 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14806 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14807 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14808 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14811 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14813 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14815 u32
*digest
= (u32
*) hash_buf
->digest
;
14817 salt_t
*salt
= hash_buf
->salt
;
14819 char *salt_pos
= input_buf
+ 6 + 1;
14821 char *digest_pos
= strchr (salt_pos
, '*');
14823 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14825 uint salt_len
= digest_pos
- salt_pos
;
14827 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14829 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14831 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14836 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14838 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14840 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14842 salt
->salt_len
= salt_len
;
14844 for (uint i
= 0; i
< salt_len
; i
++)
14846 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14848 for (uint i
= salt_len
; i
< 8; i
++)
14850 salt_buf_pc_ptr
[i
] = 0x40;
14855 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14857 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14858 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14860 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14861 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14863 digest
[0] = byte_swap_32 (digest
[0]);
14864 digest
[1] = byte_swap_32 (digest
[1]);
14866 IP (digest
[0], digest
[1], tt
);
14868 digest
[0] = rotr32 (digest
[0], 29);
14869 digest
[1] = rotr32 (digest
[1], 29);
14873 return (PARSER_OK
);
14876 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14878 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14880 u32
*digest
= (u32
*) hash_buf
->digest
;
14882 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14883 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14884 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14885 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14887 digest
[0] = byte_swap_32 (digest
[0]);
14888 digest
[1] = byte_swap_32 (digest
[1]);
14889 digest
[2] = byte_swap_32 (digest
[2]);
14890 digest
[3] = byte_swap_32 (digest
[3]);
14892 return (PARSER_OK
);
14895 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14897 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14899 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14901 u32
*digest
= (u32
*) hash_buf
->digest
;
14903 salt_t
*salt
= hash_buf
->salt
;
14905 u8 tmp_buf
[120] = { 0 };
14907 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14909 tmp_buf
[3] += -4; // dont ask!
14911 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14913 salt
->salt_len
= 5;
14915 memcpy (digest
, tmp_buf
+ 5, 9);
14917 // yes, only 9 byte are needed to crack, but 10 to display
14919 salt
->salt_buf_pc
[7] = input_buf
[20];
14921 return (PARSER_OK
);
14924 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14926 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14928 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14930 u32
*digest
= (u32
*) hash_buf
->digest
;
14932 salt_t
*salt
= hash_buf
->salt
;
14934 u8 tmp_buf
[120] = { 0 };
14936 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14938 tmp_buf
[3] += -4; // dont ask!
14942 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14944 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)
14948 char tmp_iter_buf
[11] = { 0 };
14950 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14952 tmp_iter_buf
[10] = 0;
14954 salt
->salt_iter
= atoi (tmp_iter_buf
);
14956 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14958 return (PARSER_SALT_ITERATION
);
14961 salt
->salt_iter
--; // first round in init
14963 // 2 additional bytes for display only
14965 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14966 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14970 memcpy (digest
, tmp_buf
+ 28, 8);
14972 digest
[0] = byte_swap_32 (digest
[0]);
14973 digest
[1] = byte_swap_32 (digest
[1]);
14977 return (PARSER_OK
);
14980 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14982 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14984 u32
*digest
= (u32
*) hash_buf
->digest
;
14986 salt_t
*salt
= hash_buf
->salt
;
14988 char *salt_buf_pos
= input_buf
;
14990 char *hash_buf_pos
= salt_buf_pos
+ 6;
14992 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14993 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14994 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14995 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14996 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14997 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14998 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14999 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15001 digest
[0] -= SHA256M_A
;
15002 digest
[1] -= SHA256M_B
;
15003 digest
[2] -= SHA256M_C
;
15004 digest
[3] -= SHA256M_D
;
15005 digest
[4] -= SHA256M_E
;
15006 digest
[5] -= SHA256M_F
;
15007 digest
[6] -= SHA256M_G
;
15008 digest
[7] -= SHA256M_H
;
15010 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15012 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15016 salt
->salt_len
= salt_len
;
15018 return (PARSER_OK
);
15021 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15023 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15025 u32
*digest
= (u32
*) hash_buf
->digest
;
15027 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15029 salt_t
*salt
= hash_buf
->salt
;
15031 char *salt_buf
= input_buf
+ 6;
15033 char *digest_buf
= strchr (salt_buf
, '$');
15035 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15037 uint salt_len
= digest_buf
- salt_buf
;
15039 digest_buf
++; // skip the '$' symbol
15041 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15043 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15045 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15047 salt
->salt_len
= salt_len
;
15049 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15050 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15051 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15052 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15054 digest
[0] = byte_swap_32 (digest
[0]);
15055 digest
[1] = byte_swap_32 (digest
[1]);
15056 digest
[2] = byte_swap_32 (digest
[2]);
15057 digest
[3] = byte_swap_32 (digest
[3]);
15059 digest
[0] -= MD5M_A
;
15060 digest
[1] -= MD5M_B
;
15061 digest
[2] -= MD5M_C
;
15062 digest
[3] -= MD5M_D
;
15064 return (PARSER_OK
);
15067 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15069 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15071 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15073 u32
*digest
= (u32
*) hash_buf
->digest
;
15075 salt_t
*salt
= hash_buf
->salt
;
15077 char *salt_buf
= input_buf
+ 3;
15079 char *digest_buf
= strchr (salt_buf
, '$');
15081 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15083 uint salt_len
= digest_buf
- salt_buf
;
15085 digest_buf
++; // skip the '$' symbol
15087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15089 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15091 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15093 salt_buf_ptr
[salt_len
] = 0x2d;
15095 salt
->salt_len
= salt_len
+ 1;
15097 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15098 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15099 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15100 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15102 digest
[0] = byte_swap_32 (digest
[0]);
15103 digest
[1] = byte_swap_32 (digest
[1]);
15104 digest
[2] = byte_swap_32 (digest
[2]);
15105 digest
[3] = byte_swap_32 (digest
[3]);
15107 digest
[0] -= MD5M_A
;
15108 digest
[1] -= MD5M_B
;
15109 digest
[2] -= MD5M_C
;
15110 digest
[3] -= MD5M_D
;
15112 return (PARSER_OK
);
15115 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15117 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15119 u32
*digest
= (u32
*) hash_buf
->digest
;
15121 salt_t
*salt
= hash_buf
->salt
;
15123 u8 tmp_buf
[100] = { 0 };
15125 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15127 memcpy (digest
, tmp_buf
, 20);
15129 digest
[0] = byte_swap_32 (digest
[0]);
15130 digest
[1] = byte_swap_32 (digest
[1]);
15131 digest
[2] = byte_swap_32 (digest
[2]);
15132 digest
[3] = byte_swap_32 (digest
[3]);
15133 digest
[4] = byte_swap_32 (digest
[4]);
15135 digest
[0] -= SHA1M_A
;
15136 digest
[1] -= SHA1M_B
;
15137 digest
[2] -= SHA1M_C
;
15138 digest
[3] -= SHA1M_D
;
15139 digest
[4] -= SHA1M_E
;
15141 salt
->salt_buf
[0] = 0x80;
15143 salt
->salt_len
= 0;
15145 return (PARSER_OK
);
15148 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15150 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15152 u32
*digest
= (u32
*) hash_buf
->digest
;
15154 salt_t
*salt
= hash_buf
->salt
;
15156 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15157 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15158 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15159 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15161 digest
[0] = byte_swap_32 (digest
[0]);
15162 digest
[1] = byte_swap_32 (digest
[1]);
15163 digest
[2] = byte_swap_32 (digest
[2]);
15164 digest
[3] = byte_swap_32 (digest
[3]);
15166 digest
[0] -= MD5M_A
;
15167 digest
[1] -= MD5M_B
;
15168 digest
[2] -= MD5M_C
;
15169 digest
[3] -= MD5M_D
;
15171 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15173 uint salt_len
= input_len
- 32 - 1;
15175 char *salt_buf
= input_buf
+ 32 + 1;
15177 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15179 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15181 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15184 * add static "salt" part
15187 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15191 salt
->salt_len
= salt_len
;
15193 return (PARSER_OK
);
15196 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15198 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15200 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15202 u32
*digest
= (u32
*) hash_buf
->digest
;
15204 salt_t
*salt
= hash_buf
->salt
;
15206 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15212 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15214 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15216 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15218 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15220 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15224 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15226 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15228 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15230 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15234 char *keybuf_pos
= strchr (keylen_pos
, '$');
15236 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15238 uint keylen_len
= keybuf_pos
- keylen_pos
;
15240 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15244 char *databuf_pos
= strchr (keybuf_pos
, '$');
15246 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15248 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15250 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15254 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15256 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15262 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15263 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15264 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15265 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15267 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15268 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15269 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15270 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15272 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15273 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15274 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15275 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15277 salt
->salt_len
= 16;
15278 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15280 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15282 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15285 return (PARSER_OK
);
15288 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15290 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15292 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15294 u32
*digest
= (u32
*) hash_buf
->digest
;
15296 salt_t
*salt
= hash_buf
->salt
;
15302 // first is the N salt parameter
15304 char *N_pos
= input_buf
+ 6;
15306 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15310 salt
->scrypt_N
= atoi (N_pos
);
15314 char *r_pos
= strchr (N_pos
, ':');
15316 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15320 salt
->scrypt_r
= atoi (r_pos
);
15324 char *p_pos
= strchr (r_pos
, ':');
15326 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 salt
->scrypt_p
= atoi (p_pos
);
15334 char *saltbuf_pos
= strchr (p_pos
, ':');
15336 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 char *hash_pos
= strchr (saltbuf_pos
, ':');
15342 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15348 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15350 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15352 u8 tmp_buf
[33] = { 0 };
15354 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15358 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15360 salt
->salt_len
= tmp_len
;
15361 salt
->salt_iter
= 1;
15363 // digest - base64 decode
15365 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15367 tmp_len
= input_len
- (hash_pos
- input_buf
);
15369 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15371 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15373 memcpy (digest
, tmp_buf
, 32);
15375 return (PARSER_OK
);
15378 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15380 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15382 u32
*digest
= (u32
*) hash_buf
->digest
;
15384 salt_t
*salt
= hash_buf
->salt
;
15390 char decrypted
[76] = { 0 }; // iv + hash
15392 juniper_decrypt_hash (input_buf
, decrypted
);
15394 char *md5crypt_hash
= decrypted
+ 12;
15396 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15398 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15400 char *salt_pos
= md5crypt_hash
+ 3;
15402 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15404 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15406 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15410 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15412 return (PARSER_OK
);
15415 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15417 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15419 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15421 u32
*digest
= (u32
*) hash_buf
->digest
;
15423 salt_t
*salt
= hash_buf
->salt
;
15425 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15431 // first is *raw* salt
15433 char *salt_pos
= input_buf
+ 3;
15435 char *hash_pos
= strchr (salt_pos
, '$');
15437 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15439 uint salt_len
= hash_pos
- salt_pos
;
15441 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15445 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15447 memcpy (salt_buf_ptr
, salt_pos
, 14);
15449 salt_buf_ptr
[17] = 0x01;
15450 salt_buf_ptr
[18] = 0x80;
15452 // add some stuff to normal salt to make sorted happy
15454 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15455 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15456 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15457 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15459 salt
->salt_len
= salt_len
;
15460 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15462 // base64 decode hash
15464 u8 tmp_buf
[100] = { 0 };
15466 uint hash_len
= input_len
- 3 - salt_len
- 1;
15468 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15470 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15472 memcpy (digest
, tmp_buf
, 32);
15474 digest
[0] = byte_swap_32 (digest
[0]);
15475 digest
[1] = byte_swap_32 (digest
[1]);
15476 digest
[2] = byte_swap_32 (digest
[2]);
15477 digest
[3] = byte_swap_32 (digest
[3]);
15478 digest
[4] = byte_swap_32 (digest
[4]);
15479 digest
[5] = byte_swap_32 (digest
[5]);
15480 digest
[6] = byte_swap_32 (digest
[6]);
15481 digest
[7] = byte_swap_32 (digest
[7]);
15483 return (PARSER_OK
);
15486 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15488 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15490 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15492 u32
*digest
= (u32
*) hash_buf
->digest
;
15494 salt_t
*salt
= hash_buf
->salt
;
15500 // first is *raw* salt
15502 char *salt_pos
= input_buf
+ 3;
15504 char *hash_pos
= strchr (salt_pos
, '$');
15506 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15508 uint salt_len
= hash_pos
- salt_pos
;
15510 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15512 salt
->salt_len
= salt_len
;
15515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15517 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15518 salt_buf_ptr
[salt_len
] = 0;
15520 // base64 decode hash
15522 u8 tmp_buf
[100] = { 0 };
15524 uint hash_len
= input_len
- 3 - salt_len
- 1;
15526 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15528 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15530 memcpy (digest
, tmp_buf
, 32);
15533 salt
->scrypt_N
= 16384;
15534 salt
->scrypt_r
= 1;
15535 salt
->scrypt_p
= 1;
15536 salt
->salt_iter
= 1;
15538 return (PARSER_OK
);
15541 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15543 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15545 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15547 u32
*digest
= (u32
*) hash_buf
->digest
;
15549 salt_t
*salt
= hash_buf
->salt
;
15551 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15557 char *version_pos
= input_buf
+ 8 + 1;
15559 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15561 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15563 u32 version_len
= verifierHashSize_pos
- version_pos
;
15565 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15567 verifierHashSize_pos
++;
15569 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15571 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15573 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15575 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15579 char *saltSize_pos
= strchr (keySize_pos
, '*');
15581 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15583 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15585 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15589 char *osalt_pos
= strchr (saltSize_pos
, '*');
15591 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15593 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15595 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15599 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15601 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15603 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15605 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15607 encryptedVerifier_pos
++;
15609 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15611 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15613 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15615 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15617 encryptedVerifierHash_pos
++;
15619 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;
15621 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15623 const uint version
= atoi (version_pos
);
15625 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15627 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15629 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15631 const uint keySize
= atoi (keySize_pos
);
15633 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15635 office2007
->keySize
= keySize
;
15637 const uint saltSize
= atoi (saltSize_pos
);
15639 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15645 salt
->salt_len
= 16;
15646 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15648 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15649 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15650 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15651 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15657 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15658 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15659 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15660 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15662 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15663 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15664 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15665 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15666 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15672 digest
[0] = office2007
->encryptedVerifierHash
[0];
15673 digest
[1] = office2007
->encryptedVerifierHash
[1];
15674 digest
[2] = office2007
->encryptedVerifierHash
[2];
15675 digest
[3] = office2007
->encryptedVerifierHash
[3];
15677 return (PARSER_OK
);
15680 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15682 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15684 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15686 u32
*digest
= (u32
*) hash_buf
->digest
;
15688 salt_t
*salt
= hash_buf
->salt
;
15690 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15696 char *version_pos
= input_buf
+ 8 + 1;
15698 char *spinCount_pos
= strchr (version_pos
, '*');
15700 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15702 u32 version_len
= spinCount_pos
- version_pos
;
15704 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15708 char *keySize_pos
= strchr (spinCount_pos
, '*');
15710 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15712 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15714 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15718 char *saltSize_pos
= strchr (keySize_pos
, '*');
15720 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15722 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15724 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15728 char *osalt_pos
= strchr (saltSize_pos
, '*');
15730 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15732 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15734 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15738 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15740 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15742 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15744 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15746 encryptedVerifier_pos
++;
15748 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15750 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15752 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15754 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15756 encryptedVerifierHash_pos
++;
15758 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;
15760 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15762 const uint version
= atoi (version_pos
);
15764 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15766 const uint spinCount
= atoi (spinCount_pos
);
15768 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15770 const uint keySize
= atoi (keySize_pos
);
15772 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15774 const uint saltSize
= atoi (saltSize_pos
);
15776 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15782 salt
->salt_len
= 16;
15783 salt
->salt_iter
= spinCount
;
15785 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15786 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15787 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15788 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15794 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15795 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15796 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15797 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15799 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15800 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15801 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15802 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15803 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15804 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15805 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15806 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15812 digest
[0] = office2010
->encryptedVerifierHash
[0];
15813 digest
[1] = office2010
->encryptedVerifierHash
[1];
15814 digest
[2] = office2010
->encryptedVerifierHash
[2];
15815 digest
[3] = office2010
->encryptedVerifierHash
[3];
15817 return (PARSER_OK
);
15820 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15822 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15824 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15826 u32
*digest
= (u32
*) hash_buf
->digest
;
15828 salt_t
*salt
= hash_buf
->salt
;
15830 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15836 char *version_pos
= input_buf
+ 8 + 1;
15838 char *spinCount_pos
= strchr (version_pos
, '*');
15840 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15842 u32 version_len
= spinCount_pos
- version_pos
;
15844 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15848 char *keySize_pos
= strchr (spinCount_pos
, '*');
15850 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15852 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15854 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15858 char *saltSize_pos
= strchr (keySize_pos
, '*');
15860 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15862 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15864 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15868 char *osalt_pos
= strchr (saltSize_pos
, '*');
15870 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15872 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15874 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15878 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15880 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15882 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15884 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15886 encryptedVerifier_pos
++;
15888 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15890 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15892 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15894 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15896 encryptedVerifierHash_pos
++;
15898 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;
15900 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15902 const uint version
= atoi (version_pos
);
15904 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15906 const uint spinCount
= atoi (spinCount_pos
);
15908 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15910 const uint keySize
= atoi (keySize_pos
);
15912 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15914 const uint saltSize
= atoi (saltSize_pos
);
15916 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15922 salt
->salt_len
= 16;
15923 salt
->salt_iter
= spinCount
;
15925 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15926 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15927 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15928 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15934 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15935 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15936 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15937 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15939 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15940 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15941 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15942 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15943 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15944 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15945 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15946 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15952 digest
[0] = office2013
->encryptedVerifierHash
[0];
15953 digest
[1] = office2013
->encryptedVerifierHash
[1];
15954 digest
[2] = office2013
->encryptedVerifierHash
[2];
15955 digest
[3] = office2013
->encryptedVerifierHash
[3];
15957 return (PARSER_OK
);
15960 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15962 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15964 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15966 u32
*digest
= (u32
*) hash_buf
->digest
;
15968 salt_t
*salt
= hash_buf
->salt
;
15970 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15976 char *version_pos
= input_buf
+ 11;
15978 char *osalt_pos
= strchr (version_pos
, '*');
15980 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15982 u32 version_len
= osalt_pos
- version_pos
;
15984 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15988 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15990 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15992 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15994 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15996 encryptedVerifier_pos
++;
15998 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16000 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16002 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16004 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16006 encryptedVerifierHash_pos
++;
16008 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16010 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16012 const uint version
= *version_pos
- 0x30;
16014 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16020 oldoffice01
->version
= version
;
16022 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16023 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16024 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16025 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16027 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16028 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16029 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16030 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16032 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16033 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16034 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16035 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16037 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16038 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16039 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16040 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16046 salt
->salt_len
= 16;
16048 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16049 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16050 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16051 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16053 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16054 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16055 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16056 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16058 // this is a workaround as office produces multiple documents with the same salt
16060 salt
->salt_len
+= 32;
16062 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16063 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16064 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16065 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16066 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16067 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16068 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16069 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16075 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16076 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16077 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16078 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16080 return (PARSER_OK
);
16083 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16085 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16088 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16090 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16092 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16094 u32
*digest
= (u32
*) hash_buf
->digest
;
16096 salt_t
*salt
= hash_buf
->salt
;
16098 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16104 char *version_pos
= input_buf
+ 11;
16106 char *osalt_pos
= strchr (version_pos
, '*');
16108 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16110 u32 version_len
= osalt_pos
- version_pos
;
16112 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16116 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16118 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16120 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16122 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16124 encryptedVerifier_pos
++;
16126 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16128 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16130 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16132 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16134 encryptedVerifierHash_pos
++;
16136 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16138 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16140 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16142 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16146 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16148 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16150 const uint version
= *version_pos
- 0x30;
16152 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16158 oldoffice01
->version
= version
;
16160 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16161 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16162 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16163 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16165 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16166 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16167 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16168 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16170 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16171 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16172 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16173 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16175 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16176 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16177 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16178 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16180 oldoffice01
->rc4key
[1] = 0;
16181 oldoffice01
->rc4key
[0] = 0;
16183 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16184 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16185 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16186 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16187 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16188 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16189 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16190 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16191 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16192 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16194 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16195 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16201 salt
->salt_len
= 16;
16203 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16204 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16205 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16206 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16208 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16209 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16210 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16211 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16213 // this is a workaround as office produces multiple documents with the same salt
16215 salt
->salt_len
+= 32;
16217 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16218 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16219 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16220 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16221 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16222 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16223 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16224 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16230 digest
[0] = oldoffice01
->rc4key
[0];
16231 digest
[1] = oldoffice01
->rc4key
[1];
16235 return (PARSER_OK
);
16238 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16240 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16242 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16244 u32
*digest
= (u32
*) hash_buf
->digest
;
16246 salt_t
*salt
= hash_buf
->salt
;
16248 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16254 char *version_pos
= input_buf
+ 11;
16256 char *osalt_pos
= strchr (version_pos
, '*');
16258 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16260 u32 version_len
= osalt_pos
- version_pos
;
16262 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16266 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16268 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16270 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16272 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16274 encryptedVerifier_pos
++;
16276 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16278 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16280 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16282 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16284 encryptedVerifierHash_pos
++;
16286 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16288 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16290 const uint version
= *version_pos
- 0x30;
16292 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16298 oldoffice34
->version
= version
;
16300 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16301 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16302 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16303 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16305 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16306 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16307 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16308 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16310 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16311 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16312 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16313 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16314 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16316 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16317 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16318 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16319 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16320 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16326 salt
->salt_len
= 16;
16328 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16329 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16330 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16331 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16333 // this is a workaround as office produces multiple documents with the same salt
16335 salt
->salt_len
+= 32;
16337 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16338 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16339 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16340 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16341 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16342 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16343 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16344 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16350 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16351 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16352 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16353 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16355 return (PARSER_OK
);
16358 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16360 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16362 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16365 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16367 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16369 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16371 u32
*digest
= (u32
*) hash_buf
->digest
;
16373 salt_t
*salt
= hash_buf
->salt
;
16375 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16381 char *version_pos
= input_buf
+ 11;
16383 char *osalt_pos
= strchr (version_pos
, '*');
16385 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16387 u32 version_len
= osalt_pos
- version_pos
;
16389 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16393 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16395 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16397 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16399 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16401 encryptedVerifier_pos
++;
16403 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16405 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16407 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16409 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16411 encryptedVerifierHash_pos
++;
16413 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16415 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16419 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16423 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16425 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16427 const uint version
= *version_pos
- 0x30;
16429 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16435 oldoffice34
->version
= version
;
16437 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16438 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16439 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16440 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16442 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16443 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16444 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16445 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16447 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16448 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16449 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16450 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16451 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16453 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16454 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16455 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16456 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16457 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16459 oldoffice34
->rc4key
[1] = 0;
16460 oldoffice34
->rc4key
[0] = 0;
16462 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16463 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16464 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16465 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16466 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16467 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16468 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16469 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16470 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16471 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16473 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16474 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16480 salt
->salt_len
= 16;
16482 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16483 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16484 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16485 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16487 // this is a workaround as office produces multiple documents with the same salt
16489 salt
->salt_len
+= 32;
16491 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16492 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16493 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16494 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16495 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16496 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16497 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16498 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16504 digest
[0] = oldoffice34
->rc4key
[0];
16505 digest
[1] = oldoffice34
->rc4key
[1];
16509 return (PARSER_OK
);
16512 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16514 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16516 u32
*digest
= (u32
*) hash_buf
->digest
;
16518 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16519 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16520 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16521 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16523 digest
[0] = byte_swap_32 (digest
[0]);
16524 digest
[1] = byte_swap_32 (digest
[1]);
16525 digest
[2] = byte_swap_32 (digest
[2]);
16526 digest
[3] = byte_swap_32 (digest
[3]);
16528 return (PARSER_OK
);
16531 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16533 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16535 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16537 u32
*digest
= (u32
*) hash_buf
->digest
;
16539 salt_t
*salt
= hash_buf
->salt
;
16541 char *signature_pos
= input_buf
;
16543 char *salt_pos
= strchr (signature_pos
, '$');
16545 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16547 u32 signature_len
= salt_pos
- signature_pos
;
16549 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16553 char *hash_pos
= strchr (salt_pos
, '$');
16555 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16557 u32 salt_len
= hash_pos
- salt_pos
;
16559 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16563 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16565 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16567 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16568 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16569 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16570 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16571 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16573 digest
[0] -= SHA1M_A
;
16574 digest
[1] -= SHA1M_B
;
16575 digest
[2] -= SHA1M_C
;
16576 digest
[3] -= SHA1M_D
;
16577 digest
[4] -= SHA1M_E
;
16579 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16581 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16583 salt
->salt_len
= salt_len
;
16585 return (PARSER_OK
);
16588 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16590 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16592 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16594 u32
*digest
= (u32
*) hash_buf
->digest
;
16596 salt_t
*salt
= hash_buf
->salt
;
16598 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16604 char *iter_pos
= input_buf
+ 14;
16606 const int iter
= atoi (iter_pos
);
16608 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16610 salt
->salt_iter
= iter
- 1;
16612 char *salt_pos
= strchr (iter_pos
, '$');
16614 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16618 char *hash_pos
= strchr (salt_pos
, '$');
16620 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16622 const uint salt_len
= hash_pos
- salt_pos
;
16626 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16628 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16630 salt
->salt_len
= salt_len
;
16632 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16633 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16635 // add some stuff to normal salt to make sorted happy
16637 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16638 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16639 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16640 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16641 salt
->salt_buf
[4] = salt
->salt_iter
;
16643 // base64 decode hash
16645 u8 tmp_buf
[100] = { 0 };
16647 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16649 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16651 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16653 memcpy (digest
, tmp_buf
, 32);
16655 digest
[0] = byte_swap_32 (digest
[0]);
16656 digest
[1] = byte_swap_32 (digest
[1]);
16657 digest
[2] = byte_swap_32 (digest
[2]);
16658 digest
[3] = byte_swap_32 (digest
[3]);
16659 digest
[4] = byte_swap_32 (digest
[4]);
16660 digest
[5] = byte_swap_32 (digest
[5]);
16661 digest
[6] = byte_swap_32 (digest
[6]);
16662 digest
[7] = byte_swap_32 (digest
[7]);
16664 return (PARSER_OK
);
16667 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16669 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16671 u32
*digest
= (u32
*) hash_buf
->digest
;
16673 salt_t
*salt
= hash_buf
->salt
;
16675 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16676 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16680 digest
[0] = byte_swap_32 (digest
[0]);
16681 digest
[1] = byte_swap_32 (digest
[1]);
16683 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16684 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16685 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16687 char iter_c
= input_buf
[17];
16688 char iter_d
= input_buf
[19];
16690 // atm only defaults, let's see if there's more request
16691 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16692 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16694 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16696 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16697 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16698 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16699 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16701 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16702 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16703 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16704 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16706 salt
->salt_len
= 16;
16708 return (PARSER_OK
);
16711 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16713 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16715 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16717 u32
*digest
= (u32
*) hash_buf
->digest
;
16719 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16721 salt_t
*salt
= hash_buf
->salt
;
16723 char *salt_pos
= input_buf
+ 10;
16725 char *hash_pos
= strchr (salt_pos
, '$');
16727 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16729 uint salt_len
= hash_pos
- salt_pos
;
16733 uint hash_len
= input_len
- 10 - salt_len
- 1;
16735 // base64 decode salt
16737 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16739 u8 tmp_buf
[100] = { 0 };
16741 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16743 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16745 tmp_buf
[salt_len
] = 0x80;
16747 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16749 salt
->salt_len
= salt_len
;
16751 // base64 decode hash
16753 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16755 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16757 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16759 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16761 uint user_len
= hash_len
- 32;
16763 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16765 user_len
--; // skip the trailing space
16767 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16768 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16769 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16770 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16772 digest
[0] = byte_swap_32 (digest
[0]);
16773 digest
[1] = byte_swap_32 (digest
[1]);
16774 digest
[2] = byte_swap_32 (digest
[2]);
16775 digest
[3] = byte_swap_32 (digest
[3]);
16777 // store username for host only (output hash if cracked)
16779 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16780 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16782 return (PARSER_OK
);
16785 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16787 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16789 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16791 u32
*digest
= (u32
*) hash_buf
->digest
;
16793 salt_t
*salt
= hash_buf
->salt
;
16795 char *iter_pos
= input_buf
+ 10;
16797 u32 iter
= atoi (iter_pos
);
16801 return (PARSER_SALT_ITERATION
);
16804 iter
--; // first iteration is special
16806 salt
->salt_iter
= iter
;
16808 char *base64_pos
= strchr (iter_pos
, '}');
16810 if (base64_pos
== NULL
)
16812 return (PARSER_SIGNATURE_UNMATCHED
);
16817 // base64 decode salt
16819 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16821 u8 tmp_buf
[100] = { 0 };
16823 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16825 if (decoded_len
< 24)
16827 return (PARSER_SALT_LENGTH
);
16832 uint salt_len
= decoded_len
- 20;
16834 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16835 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16837 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16839 salt
->salt_len
= salt_len
;
16843 u32
*digest_ptr
= (u32
*) tmp_buf
;
16845 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16846 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16847 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16848 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16849 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16851 return (PARSER_OK
);
16854 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16856 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16858 u32
*digest
= (u32
*) hash_buf
->digest
;
16860 salt_t
*salt
= hash_buf
->salt
;
16862 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16863 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16864 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16865 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16866 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16868 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16870 uint salt_len
= input_len
- 40 - 1;
16872 char *salt_buf
= input_buf
+ 40 + 1;
16874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16876 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16878 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16880 salt
->salt_len
= salt_len
;
16882 return (PARSER_OK
);
16885 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16887 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16889 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16891 u32
*digest
= (u32
*) hash_buf
->digest
;
16893 salt_t
*salt
= hash_buf
->salt
;
16895 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16901 char *V_pos
= input_buf
+ 5;
16903 char *R_pos
= strchr (V_pos
, '*');
16905 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16907 u32 V_len
= R_pos
- V_pos
;
16911 char *bits_pos
= strchr (R_pos
, '*');
16913 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16915 u32 R_len
= bits_pos
- R_pos
;
16919 char *P_pos
= strchr (bits_pos
, '*');
16921 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16923 u32 bits_len
= P_pos
- bits_pos
;
16927 char *enc_md_pos
= strchr (P_pos
, '*');
16929 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16931 u32 P_len
= enc_md_pos
- P_pos
;
16935 char *id_len_pos
= strchr (enc_md_pos
, '*');
16937 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16939 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16943 char *id_buf_pos
= strchr (id_len_pos
, '*');
16945 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16947 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16951 char *u_len_pos
= strchr (id_buf_pos
, '*');
16953 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16955 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16957 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16961 char *u_buf_pos
= strchr (u_len_pos
, '*');
16963 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16965 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16969 char *o_len_pos
= strchr (u_buf_pos
, '*');
16971 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16973 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16975 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16979 char *o_buf_pos
= strchr (o_len_pos
, '*');
16981 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16983 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16987 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;
16989 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16993 const int V
= atoi (V_pos
);
16994 const int R
= atoi (R_pos
);
16995 const int P
= atoi (P_pos
);
16997 if (V
!= 1) return (PARSER_SALT_VALUE
);
16998 if (R
!= 2) return (PARSER_SALT_VALUE
);
17000 const int enc_md
= atoi (enc_md_pos
);
17002 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17004 const int id_len
= atoi (id_len_pos
);
17005 const int u_len
= atoi (u_len_pos
);
17006 const int o_len
= atoi (o_len_pos
);
17008 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17009 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17010 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17012 const int bits
= atoi (bits_pos
);
17014 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17016 // copy data to esalt
17022 pdf
->enc_md
= enc_md
;
17024 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17025 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17026 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17027 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17028 pdf
->id_len
= id_len
;
17030 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17031 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17032 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17033 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17034 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17035 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17036 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17037 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17038 pdf
->u_len
= u_len
;
17040 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17041 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17042 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17043 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17044 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17045 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17046 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17047 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17048 pdf
->o_len
= o_len
;
17050 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17051 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17052 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17053 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17055 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17056 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17057 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17058 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17059 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17060 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17061 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17062 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17064 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17065 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17066 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17067 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17068 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17069 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17070 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17071 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17073 // we use ID for salt, maybe needs to change, we will see...
17075 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17076 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17077 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17078 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17079 salt
->salt_len
= pdf
->id_len
;
17081 digest
[0] = pdf
->u_buf
[0];
17082 digest
[1] = pdf
->u_buf
[1];
17083 digest
[2] = pdf
->u_buf
[2];
17084 digest
[3] = pdf
->u_buf
[3];
17086 return (PARSER_OK
);
17089 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17091 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17094 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17096 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17098 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17100 u32
*digest
= (u32
*) hash_buf
->digest
;
17102 salt_t
*salt
= hash_buf
->salt
;
17104 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17110 char *V_pos
= input_buf
+ 5;
17112 char *R_pos
= strchr (V_pos
, '*');
17114 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17116 u32 V_len
= R_pos
- V_pos
;
17120 char *bits_pos
= strchr (R_pos
, '*');
17122 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17124 u32 R_len
= bits_pos
- R_pos
;
17128 char *P_pos
= strchr (bits_pos
, '*');
17130 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17132 u32 bits_len
= P_pos
- bits_pos
;
17136 char *enc_md_pos
= strchr (P_pos
, '*');
17138 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17140 u32 P_len
= enc_md_pos
- P_pos
;
17144 char *id_len_pos
= strchr (enc_md_pos
, '*');
17146 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17148 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17152 char *id_buf_pos
= strchr (id_len_pos
, '*');
17154 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17156 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17160 char *u_len_pos
= strchr (id_buf_pos
, '*');
17162 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17164 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17166 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17170 char *u_buf_pos
= strchr (u_len_pos
, '*');
17172 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17174 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17178 char *o_len_pos
= strchr (u_buf_pos
, '*');
17180 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17182 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17184 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17188 char *o_buf_pos
= strchr (o_len_pos
, '*');
17190 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17192 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17196 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17198 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17200 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17202 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17206 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;
17208 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17212 const int V
= atoi (V_pos
);
17213 const int R
= atoi (R_pos
);
17214 const int P
= atoi (P_pos
);
17216 if (V
!= 1) return (PARSER_SALT_VALUE
);
17217 if (R
!= 2) return (PARSER_SALT_VALUE
);
17219 const int enc_md
= atoi (enc_md_pos
);
17221 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17223 const int id_len
= atoi (id_len_pos
);
17224 const int u_len
= atoi (u_len_pos
);
17225 const int o_len
= atoi (o_len_pos
);
17227 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17228 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17229 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17231 const int bits
= atoi (bits_pos
);
17233 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17235 // copy data to esalt
17241 pdf
->enc_md
= enc_md
;
17243 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17244 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17245 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17246 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17247 pdf
->id_len
= id_len
;
17249 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17250 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17251 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17252 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17253 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17254 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17255 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17256 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17257 pdf
->u_len
= u_len
;
17259 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17260 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17261 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17262 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17263 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17264 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17265 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17266 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17267 pdf
->o_len
= o_len
;
17269 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17270 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17271 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17272 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17274 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17275 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17276 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17277 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17278 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17279 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17280 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17281 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17283 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17284 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17285 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17286 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17287 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17288 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17289 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17290 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17292 pdf
->rc4key
[1] = 0;
17293 pdf
->rc4key
[0] = 0;
17295 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17296 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17297 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17298 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17299 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17300 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17301 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17302 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17303 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17304 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17306 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17307 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17309 // we use ID for salt, maybe needs to change, we will see...
17311 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17312 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17313 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17314 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17315 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17316 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17317 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17318 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17319 salt
->salt_len
= pdf
->id_len
+ 16;
17321 digest
[0] = pdf
->rc4key
[0];
17322 digest
[1] = pdf
->rc4key
[1];
17326 return (PARSER_OK
);
17329 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17331 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17333 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17335 u32
*digest
= (u32
*) hash_buf
->digest
;
17337 salt_t
*salt
= hash_buf
->salt
;
17339 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17345 char *V_pos
= input_buf
+ 5;
17347 char *R_pos
= strchr (V_pos
, '*');
17349 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17351 u32 V_len
= R_pos
- V_pos
;
17355 char *bits_pos
= strchr (R_pos
, '*');
17357 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17359 u32 R_len
= bits_pos
- R_pos
;
17363 char *P_pos
= strchr (bits_pos
, '*');
17365 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17367 u32 bits_len
= P_pos
- bits_pos
;
17371 char *enc_md_pos
= strchr (P_pos
, '*');
17373 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 u32 P_len
= enc_md_pos
- P_pos
;
17379 char *id_len_pos
= strchr (enc_md_pos
, '*');
17381 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17383 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17387 char *id_buf_pos
= strchr (id_len_pos
, '*');
17389 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17391 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17395 char *u_len_pos
= strchr (id_buf_pos
, '*');
17397 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17399 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17401 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17405 char *u_buf_pos
= strchr (u_len_pos
, '*');
17407 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17409 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17413 char *o_len_pos
= strchr (u_buf_pos
, '*');
17415 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17417 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17419 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17423 char *o_buf_pos
= strchr (o_len_pos
, '*');
17425 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17427 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17431 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;
17433 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17437 const int V
= atoi (V_pos
);
17438 const int R
= atoi (R_pos
);
17439 const int P
= atoi (P_pos
);
17443 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17444 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17446 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17448 const int id_len
= atoi (id_len_pos
);
17449 const int u_len
= atoi (u_len_pos
);
17450 const int o_len
= atoi (o_len_pos
);
17452 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17454 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17455 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17457 const int bits
= atoi (bits_pos
);
17459 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17465 enc_md
= atoi (enc_md_pos
);
17468 // copy data to esalt
17474 pdf
->enc_md
= enc_md
;
17476 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17477 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17478 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17479 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17483 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17484 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17485 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17486 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17489 pdf
->id_len
= id_len
;
17491 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17492 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17493 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17494 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17495 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17496 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17497 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17498 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17499 pdf
->u_len
= u_len
;
17501 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17502 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17503 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17504 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17505 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17506 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17507 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17508 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17509 pdf
->o_len
= o_len
;
17511 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17512 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17513 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17514 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17518 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17519 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17520 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17521 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17524 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17525 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17526 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17527 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17528 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17529 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17530 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17531 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17533 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17534 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17535 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17536 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17537 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17538 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17539 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17540 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17542 // precompute rc4 data for later use
17558 uint salt_pc_block
[32] = { 0 };
17560 char *salt_pc_ptr
= (char *) salt_pc_block
;
17562 memcpy (salt_pc_ptr
, padding
, 32);
17563 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17565 uint salt_pc_digest
[4] = { 0 };
17567 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17569 pdf
->rc4data
[0] = salt_pc_digest
[0];
17570 pdf
->rc4data
[1] = salt_pc_digest
[1];
17572 // we use ID for salt, maybe needs to change, we will see...
17574 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17575 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17576 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17577 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17578 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17579 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17580 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17581 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17582 salt
->salt_len
= pdf
->id_len
+ 16;
17584 salt
->salt_iter
= ROUNDS_PDF14
;
17586 digest
[0] = pdf
->u_buf
[0];
17587 digest
[1] = pdf
->u_buf
[1];
17591 return (PARSER_OK
);
17594 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17596 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17598 if (ret
!= PARSER_OK
)
17603 u32
*digest
= (u32
*) hash_buf
->digest
;
17605 salt_t
*salt
= hash_buf
->salt
;
17607 digest
[0] -= SHA256M_A
;
17608 digest
[1] -= SHA256M_B
;
17609 digest
[2] -= SHA256M_C
;
17610 digest
[3] -= SHA256M_D
;
17611 digest
[4] -= SHA256M_E
;
17612 digest
[5] -= SHA256M_F
;
17613 digest
[6] -= SHA256M_G
;
17614 digest
[7] -= SHA256M_H
;
17616 salt
->salt_buf
[2] = 0x80;
17618 return (PARSER_OK
);
17621 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17623 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17625 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17627 u32
*digest
= (u32
*) hash_buf
->digest
;
17629 salt_t
*salt
= hash_buf
->salt
;
17631 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17637 char *V_pos
= input_buf
+ 5;
17639 char *R_pos
= strchr (V_pos
, '*');
17641 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17643 u32 V_len
= R_pos
- V_pos
;
17647 char *bits_pos
= strchr (R_pos
, '*');
17649 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17651 u32 R_len
= bits_pos
- R_pos
;
17655 char *P_pos
= strchr (bits_pos
, '*');
17657 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17659 u32 bits_len
= P_pos
- bits_pos
;
17663 char *enc_md_pos
= strchr (P_pos
, '*');
17665 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17667 u32 P_len
= enc_md_pos
- P_pos
;
17671 char *id_len_pos
= strchr (enc_md_pos
, '*');
17673 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17675 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17679 char *id_buf_pos
= strchr (id_len_pos
, '*');
17681 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17683 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17687 char *u_len_pos
= strchr (id_buf_pos
, '*');
17689 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17691 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17695 char *u_buf_pos
= strchr (u_len_pos
, '*');
17697 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17699 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17703 char *o_len_pos
= strchr (u_buf_pos
, '*');
17705 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17707 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17711 char *o_buf_pos
= strchr (o_len_pos
, '*');
17713 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17715 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17719 char *last
= strchr (o_buf_pos
, '*');
17721 if (last
== NULL
) last
= input_buf
+ input_len
;
17723 u32 o_buf_len
= last
- o_buf_pos
;
17727 const int V
= atoi (V_pos
);
17728 const int R
= atoi (R_pos
);
17732 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17733 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17735 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17737 const int bits
= atoi (bits_pos
);
17739 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17741 int enc_md
= atoi (enc_md_pos
);
17743 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17745 const uint id_len
= atoi (id_len_pos
);
17746 const uint u_len
= atoi (u_len_pos
);
17747 const uint o_len
= atoi (o_len_pos
);
17749 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17750 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17751 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17752 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17753 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17754 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17755 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17756 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17758 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17759 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17760 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17762 // copy data to esalt
17764 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17766 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17768 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17771 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17772 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17774 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17775 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17777 salt
->salt_len
= 8;
17778 salt
->salt_iter
= ROUNDS_PDF17L8
;
17780 digest
[0] = pdf
->u_buf
[0];
17781 digest
[1] = pdf
->u_buf
[1];
17782 digest
[2] = pdf
->u_buf
[2];
17783 digest
[3] = pdf
->u_buf
[3];
17784 digest
[4] = pdf
->u_buf
[4];
17785 digest
[5] = pdf
->u_buf
[5];
17786 digest
[6] = pdf
->u_buf
[6];
17787 digest
[7] = pdf
->u_buf
[7];
17789 return (PARSER_OK
);
17792 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17794 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17796 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17798 u32
*digest
= (u32
*) hash_buf
->digest
;
17800 salt_t
*salt
= hash_buf
->salt
;
17802 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17810 char *iter_pos
= input_buf
+ 7;
17812 u32 iter
= atoi (iter_pos
);
17814 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17815 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17817 // first is *raw* salt
17819 char *salt_pos
= strchr (iter_pos
, ':');
17821 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17825 char *hash_pos
= strchr (salt_pos
, ':');
17827 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17829 u32 salt_len
= hash_pos
- salt_pos
;
17831 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17835 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17837 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17841 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17843 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17845 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17847 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17848 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17850 salt
->salt_len
= salt_len
;
17851 salt
->salt_iter
= iter
- 1;
17855 u8 tmp_buf
[100] = { 0 };
17857 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17859 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17861 memcpy (digest
, tmp_buf
, 16);
17863 digest
[0] = byte_swap_32 (digest
[0]);
17864 digest
[1] = byte_swap_32 (digest
[1]);
17865 digest
[2] = byte_swap_32 (digest
[2]);
17866 digest
[3] = byte_swap_32 (digest
[3]);
17868 // add some stuff to normal salt to make sorted happy
17870 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17871 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17872 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17873 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17874 salt
->salt_buf
[4] = salt
->salt_iter
;
17876 return (PARSER_OK
);
17879 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17881 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17883 u32
*digest
= (u32
*) hash_buf
->digest
;
17885 salt_t
*salt
= hash_buf
->salt
;
17887 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17888 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17889 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17890 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17892 digest
[0] = byte_swap_32 (digest
[0]);
17893 digest
[1] = byte_swap_32 (digest
[1]);
17894 digest
[2] = byte_swap_32 (digest
[2]);
17895 digest
[3] = byte_swap_32 (digest
[3]);
17897 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17899 uint salt_len
= input_len
- 32 - 1;
17901 char *salt_buf
= input_buf
+ 32 + 1;
17903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17905 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17907 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17909 salt
->salt_len
= salt_len
;
17911 return (PARSER_OK
);
17914 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17916 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17918 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17920 u32
*digest
= (u32
*) hash_buf
->digest
;
17922 salt_t
*salt
= hash_buf
->salt
;
17924 char *user_pos
= input_buf
+ 10;
17926 char *salt_pos
= strchr (user_pos
, '*');
17928 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17932 char *hash_pos
= strchr (salt_pos
, '*');
17936 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17938 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17940 uint user_len
= salt_pos
- user_pos
- 1;
17942 uint salt_len
= hash_pos
- salt_pos
- 1;
17944 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17950 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17951 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17952 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17953 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17955 digest
[0] = byte_swap_32 (digest
[0]);
17956 digest
[1] = byte_swap_32 (digest
[1]);
17957 digest
[2] = byte_swap_32 (digest
[2]);
17958 digest
[3] = byte_swap_32 (digest
[3]);
17960 digest
[0] -= MD5M_A
;
17961 digest
[1] -= MD5M_B
;
17962 digest
[2] -= MD5M_C
;
17963 digest
[3] -= MD5M_D
;
17969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17971 // first 4 bytes are the "challenge"
17973 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17974 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17975 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17976 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17978 // append the user name
17980 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17982 salt
->salt_len
= 4 + user_len
;
17984 return (PARSER_OK
);
17987 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17989 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17991 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17993 u32
*digest
= (u32
*) hash_buf
->digest
;
17995 salt_t
*salt
= hash_buf
->salt
;
17997 char *salt_pos
= input_buf
+ 9;
17999 char *hash_pos
= strchr (salt_pos
, '*');
18001 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18005 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18007 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18009 uint salt_len
= hash_pos
- salt_pos
- 1;
18011 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18017 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18018 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18019 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18020 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18021 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18027 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18029 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18031 salt
->salt_len
= salt_len
;
18033 return (PARSER_OK
);
18036 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18038 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18040 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18042 u32
*digest
= (u32
*) hash_buf
->digest
;
18044 salt_t
*salt
= hash_buf
->salt
;
18046 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18052 char *cry_master_len_pos
= input_buf
+ 9;
18054 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18056 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18058 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18060 cry_master_buf_pos
++;
18062 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18064 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18066 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18068 cry_salt_len_pos
++;
18070 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18072 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18074 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18076 cry_salt_buf_pos
++;
18078 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18080 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18082 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18086 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18088 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18090 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18094 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18096 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18098 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18102 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18104 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18106 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18108 public_key_len_pos
++;
18110 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18112 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18114 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18116 public_key_buf_pos
++;
18118 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;
18120 const uint cry_master_len
= atoi (cry_master_len_pos
);
18121 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18122 const uint ckey_len
= atoi (ckey_len_pos
);
18123 const uint public_key_len
= atoi (public_key_len_pos
);
18125 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18126 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18127 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18128 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18130 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18132 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18134 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18137 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18139 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18141 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18144 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18146 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18148 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18151 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18152 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18153 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18156 * store digest (should be unique enought, hopefully)
18159 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18160 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18161 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18162 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18168 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18170 const uint cry_rounds
= atoi (cry_rounds_pos
);
18172 salt
->salt_iter
= cry_rounds
- 1;
18174 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18176 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18178 salt
->salt_len
= salt_len
;
18180 return (PARSER_OK
);
18183 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18185 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18187 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18189 u32
*digest
= (u32
*) hash_buf
->digest
;
18191 salt_t
*salt
= hash_buf
->salt
;
18193 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18195 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18197 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18199 memcpy (temp_input_buf
, input_buf
, input_len
);
18203 char *URI_server_pos
= temp_input_buf
+ 6;
18205 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18207 if (URI_client_pos
== NULL
)
18209 myfree (temp_input_buf
);
18211 return (PARSER_SEPARATOR_UNMATCHED
);
18214 URI_client_pos
[0] = 0;
18217 uint URI_server_len
= strlen (URI_server_pos
);
18219 if (URI_server_len
> 512)
18221 myfree (temp_input_buf
);
18223 return (PARSER_SALT_LENGTH
);
18228 char *user_pos
= strchr (URI_client_pos
, '*');
18230 if (user_pos
== NULL
)
18232 myfree (temp_input_buf
);
18234 return (PARSER_SEPARATOR_UNMATCHED
);
18240 uint URI_client_len
= strlen (URI_client_pos
);
18242 if (URI_client_len
> 512)
18244 myfree (temp_input_buf
);
18246 return (PARSER_SALT_LENGTH
);
18251 char *realm_pos
= strchr (user_pos
, '*');
18253 if (realm_pos
== NULL
)
18255 myfree (temp_input_buf
);
18257 return (PARSER_SEPARATOR_UNMATCHED
);
18263 uint user_len
= strlen (user_pos
);
18265 if (user_len
> 116)
18267 myfree (temp_input_buf
);
18269 return (PARSER_SALT_LENGTH
);
18274 char *method_pos
= strchr (realm_pos
, '*');
18276 if (method_pos
== NULL
)
18278 myfree (temp_input_buf
);
18280 return (PARSER_SEPARATOR_UNMATCHED
);
18286 uint realm_len
= strlen (realm_pos
);
18288 if (realm_len
> 116)
18290 myfree (temp_input_buf
);
18292 return (PARSER_SALT_LENGTH
);
18297 char *URI_prefix_pos
= strchr (method_pos
, '*');
18299 if (URI_prefix_pos
== NULL
)
18301 myfree (temp_input_buf
);
18303 return (PARSER_SEPARATOR_UNMATCHED
);
18306 URI_prefix_pos
[0] = 0;
18309 uint method_len
= strlen (method_pos
);
18311 if (method_len
> 246)
18313 myfree (temp_input_buf
);
18315 return (PARSER_SALT_LENGTH
);
18320 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18322 if (URI_resource_pos
== NULL
)
18324 myfree (temp_input_buf
);
18326 return (PARSER_SEPARATOR_UNMATCHED
);
18329 URI_resource_pos
[0] = 0;
18330 URI_resource_pos
++;
18332 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18334 if (URI_prefix_len
> 245)
18336 myfree (temp_input_buf
);
18338 return (PARSER_SALT_LENGTH
);
18343 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18345 if (URI_suffix_pos
== NULL
)
18347 myfree (temp_input_buf
);
18349 return (PARSER_SEPARATOR_UNMATCHED
);
18352 URI_suffix_pos
[0] = 0;
18355 uint URI_resource_len
= strlen (URI_resource_pos
);
18357 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18359 myfree (temp_input_buf
);
18361 return (PARSER_SALT_LENGTH
);
18366 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18368 if (nonce_pos
== NULL
)
18370 myfree (temp_input_buf
);
18372 return (PARSER_SEPARATOR_UNMATCHED
);
18378 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18380 if (URI_suffix_len
> 245)
18382 myfree (temp_input_buf
);
18384 return (PARSER_SALT_LENGTH
);
18389 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18391 if (nonce_client_pos
== NULL
)
18393 myfree (temp_input_buf
);
18395 return (PARSER_SEPARATOR_UNMATCHED
);
18398 nonce_client_pos
[0] = 0;
18399 nonce_client_pos
++;
18401 uint nonce_len
= strlen (nonce_pos
);
18403 if (nonce_len
< 1 || nonce_len
> 50)
18405 myfree (temp_input_buf
);
18407 return (PARSER_SALT_LENGTH
);
18412 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18414 if (nonce_count_pos
== NULL
)
18416 myfree (temp_input_buf
);
18418 return (PARSER_SEPARATOR_UNMATCHED
);
18421 nonce_count_pos
[0] = 0;
18424 uint nonce_client_len
= strlen (nonce_client_pos
);
18426 if (nonce_client_len
> 50)
18428 myfree (temp_input_buf
);
18430 return (PARSER_SALT_LENGTH
);
18435 char *qop_pos
= strchr (nonce_count_pos
, '*');
18437 if (qop_pos
== NULL
)
18439 myfree (temp_input_buf
);
18441 return (PARSER_SEPARATOR_UNMATCHED
);
18447 uint nonce_count_len
= strlen (nonce_count_pos
);
18449 if (nonce_count_len
> 50)
18451 myfree (temp_input_buf
);
18453 return (PARSER_SALT_LENGTH
);
18458 char *directive_pos
= strchr (qop_pos
, '*');
18460 if (directive_pos
== NULL
)
18462 myfree (temp_input_buf
);
18464 return (PARSER_SEPARATOR_UNMATCHED
);
18467 directive_pos
[0] = 0;
18470 uint qop_len
= strlen (qop_pos
);
18474 myfree (temp_input_buf
);
18476 return (PARSER_SALT_LENGTH
);
18481 char *digest_pos
= strchr (directive_pos
, '*');
18483 if (digest_pos
== NULL
)
18485 myfree (temp_input_buf
);
18487 return (PARSER_SEPARATOR_UNMATCHED
);
18493 uint directive_len
= strlen (directive_pos
);
18495 if (directive_len
!= 3)
18497 myfree (temp_input_buf
);
18499 return (PARSER_SALT_LENGTH
);
18502 if (memcmp (directive_pos
, "MD5", 3))
18504 log_info ("ERROR: only the MD5 directive is currently supported\n");
18506 myfree (temp_input_buf
);
18508 return (PARSER_SIP_AUTH_DIRECTIVE
);
18512 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18517 uint md5_max_len
= 4 * 64;
18519 uint md5_remaining_len
= md5_max_len
;
18521 uint tmp_md5_buf
[64] = { 0 };
18523 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18525 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18527 md5_len
+= method_len
+ 1;
18528 tmp_md5_ptr
+= method_len
+ 1;
18530 if (URI_prefix_len
> 0)
18532 md5_remaining_len
= md5_max_len
- md5_len
;
18534 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18536 md5_len
+= URI_prefix_len
+ 1;
18537 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18540 md5_remaining_len
= md5_max_len
- md5_len
;
18542 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18544 md5_len
+= URI_resource_len
;
18545 tmp_md5_ptr
+= URI_resource_len
;
18547 if (URI_suffix_len
> 0)
18549 md5_remaining_len
= md5_max_len
- md5_len
;
18551 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18553 md5_len
+= 1 + URI_suffix_len
;
18556 uint tmp_digest
[4] = { 0 };
18558 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18560 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18561 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18562 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18563 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18569 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18571 uint esalt_len
= 0;
18573 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18575 // there are 2 possibilities for the esalt:
18577 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18579 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18581 if (esalt_len
> max_esalt_len
)
18583 myfree (temp_input_buf
);
18585 return (PARSER_SALT_LENGTH
);
18588 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18600 esalt_len
= 1 + nonce_len
+ 1 + 32;
18602 if (esalt_len
> max_esalt_len
)
18604 myfree (temp_input_buf
);
18606 return (PARSER_SALT_LENGTH
);
18609 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18617 // add 0x80 to esalt
18619 esalt_buf_ptr
[esalt_len
] = 0x80;
18621 sip
->esalt_len
= esalt_len
;
18627 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18629 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18631 uint max_salt_len
= 119;
18633 if (salt_len
> max_salt_len
)
18635 myfree (temp_input_buf
);
18637 return (PARSER_SALT_LENGTH
);
18640 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18642 sip
->salt_len
= salt_len
;
18645 * fake salt (for sorting)
18648 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18652 uint fake_salt_len
= salt_len
;
18654 if (fake_salt_len
> max_salt_len
)
18656 fake_salt_len
= max_salt_len
;
18659 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18661 salt
->salt_len
= fake_salt_len
;
18667 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18668 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18669 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18670 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18672 digest
[0] = byte_swap_32 (digest
[0]);
18673 digest
[1] = byte_swap_32 (digest
[1]);
18674 digest
[2] = byte_swap_32 (digest
[2]);
18675 digest
[3] = byte_swap_32 (digest
[3]);
18677 myfree (temp_input_buf
);
18679 return (PARSER_OK
);
18682 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18684 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18686 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18688 u32
*digest
= (u32
*) hash_buf
->digest
;
18690 salt_t
*salt
= hash_buf
->salt
;
18694 char *digest_pos
= input_buf
;
18696 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18703 char *salt_buf
= input_buf
+ 8 + 1;
18707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18713 salt
->salt_len
= salt_len
;
18715 return (PARSER_OK
);
18718 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18720 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18722 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18724 u32
*digest
= (u32
*) hash_buf
->digest
;
18726 salt_t
*salt
= hash_buf
->salt
;
18728 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18734 char *p_buf_pos
= input_buf
+ 4;
18736 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18738 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18740 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18742 NumCyclesPower_pos
++;
18744 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18746 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18748 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18752 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18754 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18756 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18760 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18762 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18764 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18768 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18770 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18772 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18776 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18778 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18780 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18784 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18786 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18788 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18792 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18794 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18796 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18800 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18802 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18804 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18808 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;
18810 const uint iter
= atoi (NumCyclesPower_pos
);
18811 const uint crc
= atoi (crc_buf_pos
);
18812 const uint p_buf
= atoi (p_buf_pos
);
18813 const uint salt_len
= atoi (salt_len_pos
);
18814 const uint iv_len
= atoi (iv_len_pos
);
18815 const uint unpack_size
= atoi (unpack_size_pos
);
18816 const uint data_len
= atoi (data_len_pos
);
18822 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18823 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18825 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18827 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18829 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18835 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18836 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18837 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18838 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18840 seven_zip
->iv_len
= iv_len
;
18842 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18844 seven_zip
->salt_len
= 0;
18846 seven_zip
->crc
= crc
;
18848 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18850 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18852 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18855 seven_zip
->data_len
= data_len
;
18857 seven_zip
->unpack_size
= unpack_size
;
18861 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18862 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18863 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18864 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18866 salt
->salt_len
= 16;
18868 salt
->salt_sign
[0] = iter
;
18870 salt
->salt_iter
= 1 << iter
;
18881 return (PARSER_OK
);
18884 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18886 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18888 u32
*digest
= (u32
*) hash_buf
->digest
;
18890 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18891 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18892 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18893 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18894 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18895 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18896 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18897 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18899 digest
[0] = byte_swap_32 (digest
[0]);
18900 digest
[1] = byte_swap_32 (digest
[1]);
18901 digest
[2] = byte_swap_32 (digest
[2]);
18902 digest
[3] = byte_swap_32 (digest
[3]);
18903 digest
[4] = byte_swap_32 (digest
[4]);
18904 digest
[5] = byte_swap_32 (digest
[5]);
18905 digest
[6] = byte_swap_32 (digest
[6]);
18906 digest
[7] = byte_swap_32 (digest
[7]);
18908 return (PARSER_OK
);
18911 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18913 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18915 u32
*digest
= (u32
*) hash_buf
->digest
;
18917 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18918 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18919 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18920 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18921 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18922 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18923 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18924 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18925 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18926 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18927 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18928 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18929 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18930 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18931 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18932 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18934 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18935 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18936 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18937 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18938 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18939 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18940 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18941 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18942 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18943 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18944 digest
[10] = byte_swap_32 (digest
[10]);
18945 digest
[11] = byte_swap_32 (digest
[11]);
18946 digest
[12] = byte_swap_32 (digest
[12]);
18947 digest
[13] = byte_swap_32 (digest
[13]);
18948 digest
[14] = byte_swap_32 (digest
[14]);
18949 digest
[15] = byte_swap_32 (digest
[15]);
18951 return (PARSER_OK
);
18954 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18956 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18958 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18960 u32
*digest
= (u32
*) hash_buf
->digest
;
18962 salt_t
*salt
= hash_buf
->salt
;
18964 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18972 char *iter_pos
= input_buf
+ 4;
18974 u32 iter
= atoi (iter_pos
);
18976 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18977 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18979 // first is *raw* salt
18981 char *salt_pos
= strchr (iter_pos
, ':');
18983 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18987 char *hash_pos
= strchr (salt_pos
, ':');
18989 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18991 u32 salt_len
= hash_pos
- salt_pos
;
18993 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18997 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18999 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19003 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19009 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19010 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19012 salt
->salt_len
= salt_len
;
19013 salt
->salt_iter
= iter
- 1;
19017 u8 tmp_buf
[100] = { 0 };
19019 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19021 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19023 memcpy (digest
, tmp_buf
, 16);
19025 // add some stuff to normal salt to make sorted happy
19027 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19028 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19029 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19030 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19031 salt
->salt_buf
[4] = salt
->salt_iter
;
19033 return (PARSER_OK
);
19036 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19038 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19040 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19042 u32
*digest
= (u32
*) hash_buf
->digest
;
19044 salt_t
*salt
= hash_buf
->salt
;
19046 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19054 char *iter_pos
= input_buf
+ 5;
19056 u32 iter
= atoi (iter_pos
);
19058 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19059 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19061 // first is *raw* salt
19063 char *salt_pos
= strchr (iter_pos
, ':');
19065 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19069 char *hash_pos
= strchr (salt_pos
, ':');
19071 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19073 u32 salt_len
= hash_pos
- salt_pos
;
19075 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19079 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19081 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19085 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19091 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19092 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19094 salt
->salt_len
= salt_len
;
19095 salt
->salt_iter
= iter
- 1;
19099 u8 tmp_buf
[100] = { 0 };
19101 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19103 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19105 memcpy (digest
, tmp_buf
, 16);
19107 digest
[0] = byte_swap_32 (digest
[0]);
19108 digest
[1] = byte_swap_32 (digest
[1]);
19109 digest
[2] = byte_swap_32 (digest
[2]);
19110 digest
[3] = byte_swap_32 (digest
[3]);
19112 // add some stuff to normal salt to make sorted happy
19114 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19115 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19116 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19117 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19118 salt
->salt_buf
[4] = salt
->salt_iter
;
19120 return (PARSER_OK
);
19123 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19125 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19127 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19129 u64
*digest
= (u64
*) hash_buf
->digest
;
19131 salt_t
*salt
= hash_buf
->salt
;
19133 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19141 char *iter_pos
= input_buf
+ 7;
19143 u32 iter
= atoi (iter_pos
);
19145 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19146 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19148 // first is *raw* salt
19150 char *salt_pos
= strchr (iter_pos
, ':');
19152 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19156 char *hash_pos
= strchr (salt_pos
, ':');
19158 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19160 u32 salt_len
= hash_pos
- salt_pos
;
19162 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19166 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19168 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19172 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19178 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19179 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19181 salt
->salt_len
= salt_len
;
19182 salt
->salt_iter
= iter
- 1;
19186 u8 tmp_buf
[100] = { 0 };
19188 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19190 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19192 memcpy (digest
, tmp_buf
, 64);
19194 digest
[0] = byte_swap_64 (digest
[0]);
19195 digest
[1] = byte_swap_64 (digest
[1]);
19196 digest
[2] = byte_swap_64 (digest
[2]);
19197 digest
[3] = byte_swap_64 (digest
[3]);
19198 digest
[4] = byte_swap_64 (digest
[4]);
19199 digest
[5] = byte_swap_64 (digest
[5]);
19200 digest
[6] = byte_swap_64 (digest
[6]);
19201 digest
[7] = byte_swap_64 (digest
[7]);
19203 // add some stuff to normal salt to make sorted happy
19205 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19206 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19207 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19208 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19209 salt
->salt_buf
[4] = salt
->salt_iter
;
19211 return (PARSER_OK
);
19214 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19216 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19218 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19220 uint
*digest
= (uint
*) hash_buf
->digest
;
19222 salt_t
*salt
= hash_buf
->salt
;
19228 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19230 char *hash_pos
= strchr (salt_pos
, '$');
19232 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19234 u32 salt_len
= hash_pos
- salt_pos
;
19236 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19240 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19242 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19246 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19247 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19265 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19266 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19268 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19269 salt
->salt_len
= 8;
19271 return (PARSER_OK
);
19274 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19276 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19278 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19280 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19282 if (c19
& 3) return (PARSER_HASH_VALUE
);
19284 salt_t
*salt
= hash_buf
->salt
;
19286 u32
*digest
= (u32
*) hash_buf
->digest
;
19290 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19291 | itoa64_to_int (input_buf
[2]) << 6
19292 | itoa64_to_int (input_buf
[3]) << 12
19293 | itoa64_to_int (input_buf
[4]) << 18;
19297 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19298 | itoa64_to_int (input_buf
[6]) << 6
19299 | itoa64_to_int (input_buf
[7]) << 12
19300 | itoa64_to_int (input_buf
[8]) << 18;
19302 salt
->salt_len
= 4;
19304 u8 tmp_buf
[100] = { 0 };
19306 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19308 memcpy (digest
, tmp_buf
, 8);
19312 IP (digest
[0], digest
[1], tt
);
19314 digest
[0] = rotr32 (digest
[0], 31);
19315 digest
[1] = rotr32 (digest
[1], 31);
19319 return (PARSER_OK
);
19322 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19324 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19326 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19328 u32
*digest
= (u32
*) hash_buf
->digest
;
19330 salt_t
*salt
= hash_buf
->salt
;
19336 char *type_pos
= input_buf
+ 6 + 1;
19338 char *salt_pos
= strchr (type_pos
, '*');
19340 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19342 u32 type_len
= salt_pos
- type_pos
;
19344 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19348 char *crypted_pos
= strchr (salt_pos
, '*');
19350 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19352 u32 salt_len
= crypted_pos
- salt_pos
;
19354 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19358 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19360 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19366 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19367 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19369 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19370 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19372 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19373 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19374 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19375 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19377 salt
->salt_len
= 24;
19378 salt
->salt_iter
= ROUNDS_RAR3
;
19380 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19381 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19383 digest
[0] = 0xc43d7b00;
19384 digest
[1] = 0x40070000;
19388 return (PARSER_OK
);
19391 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19393 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19395 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19397 u32
*digest
= (u32
*) hash_buf
->digest
;
19399 salt_t
*salt
= hash_buf
->salt
;
19401 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19407 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19409 char *param1_pos
= strchr (param0_pos
, '$');
19411 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19413 u32 param0_len
= param1_pos
- param0_pos
;
19417 char *param2_pos
= strchr (param1_pos
, '$');
19419 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19421 u32 param1_len
= param2_pos
- param1_pos
;
19425 char *param3_pos
= strchr (param2_pos
, '$');
19427 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19429 u32 param2_len
= param3_pos
- param2_pos
;
19433 char *param4_pos
= strchr (param3_pos
, '$');
19435 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19437 u32 param3_len
= param4_pos
- param3_pos
;
19441 char *param5_pos
= strchr (param4_pos
, '$');
19443 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19445 u32 param4_len
= param5_pos
- param4_pos
;
19449 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19451 char *salt_buf
= param1_pos
;
19452 char *iv
= param3_pos
;
19453 char *pswcheck
= param5_pos
;
19455 const uint salt_len
= atoi (param0_pos
);
19456 const uint iterations
= atoi (param2_pos
);
19457 const uint pswcheck_len
= atoi (param4_pos
);
19463 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19464 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19465 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19467 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19468 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19469 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19475 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19476 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19477 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19478 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19480 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19481 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19482 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19483 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19485 salt
->salt_len
= 16;
19487 salt
->salt_sign
[0] = iterations
;
19489 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19495 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19496 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19500 return (PARSER_OK
);
19503 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19505 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19507 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19509 u32
*digest
= (u32
*) hash_buf
->digest
;
19511 salt_t
*salt
= hash_buf
->salt
;
19513 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19520 char *account_pos
= input_buf
+ 11 + 1;
19526 if (account_pos
[0] == '*')
19530 data_pos
= strchr (account_pos
, '*');
19535 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19537 uint account_len
= data_pos
- account_pos
+ 1;
19539 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19544 data_len
= input_len
- 11 - 1 - account_len
- 2;
19546 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19550 /* assume $krb5tgs$23$checksum$edata2 */
19551 data_pos
= account_pos
;
19553 memcpy (krb5tgs
->account_info
, "**", 3);
19555 data_len
= input_len
- 11 - 1 - 1;
19558 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19560 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19562 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19564 const char p0
= data_pos
[i
+ 0];
19565 const char p1
= data_pos
[i
+ 1];
19567 *checksum_ptr
++ = hex_convert (p1
) << 0
19568 | hex_convert (p0
) << 4;
19571 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19573 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19576 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19578 const char p0
= data_pos
[i
+ 0];
19579 const char p1
= data_pos
[i
+ 1];
19580 *edata_ptr
++ = hex_convert (p1
) << 0
19581 | hex_convert (p0
) << 4;
19584 /* this is needed for hmac_md5 */
19585 *edata_ptr
++ = 0x80;
19587 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19588 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19589 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19590 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19592 salt
->salt_len
= 32;
19594 digest
[0] = krb5tgs
->checksum
[0];
19595 digest
[1] = krb5tgs
->checksum
[1];
19596 digest
[2] = krb5tgs
->checksum
[2];
19597 digest
[3] = krb5tgs
->checksum
[3];
19599 return (PARSER_OK
);
19602 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19604 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19606 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19608 u32
*digest
= (u32
*) hash_buf
->digest
;
19610 salt_t
*salt
= hash_buf
->salt
;
19617 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19621 char *wrapped_key_pos
;
19625 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19627 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19629 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19631 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19636 data_pos
= salt_pos
;
19638 wrapped_key_pos
= strchr (salt_pos
, '*');
19640 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19642 uint salt_len
= wrapped_key_pos
- salt_pos
;
19644 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19649 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19651 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19653 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19654 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19655 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19656 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19660 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19661 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19662 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19663 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19664 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19665 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19667 salt
->salt_len
= 40;
19669 digest
[0] = salt
->salt_buf
[0];
19670 digest
[1] = salt
->salt_buf
[1];
19671 digest
[2] = salt
->salt_buf
[2];
19672 digest
[3] = salt
->salt_buf
[3];
19674 return (PARSER_OK
);
19677 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19679 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19681 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19683 u32
*digest
= (u32
*) hash_buf
->digest
;
19685 salt_t
*salt
= hash_buf
->salt
;
19687 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19697 char *algorithm_pos
;
19699 char *final_random_seed_pos
;
19700 u32 final_random_seed_len
;
19702 char *transf_random_seed_pos
;
19703 u32 transf_random_seed_len
;
19708 /* default is no keyfile provided */
19709 char *keyfile_len_pos
;
19710 u32 keyfile_len
= 0;
19711 u32 is_keyfile_present
= 0;
19712 char *keyfile_inline_pos
;
19715 /* specific to version 1 */
19716 char *contents_len_pos
;
19718 char *contents_pos
;
19720 /* specific to version 2 */
19721 char *expected_bytes_pos
;
19722 u32 expected_bytes_len
;
19724 char *contents_hash_pos
;
19725 u32 contents_hash_len
;
19727 version_pos
= input_buf
+ 8 + 1 + 1;
19729 keepass
->version
= atoi (version_pos
);
19731 rounds_pos
= strchr (version_pos
, '*');
19733 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19737 salt
->salt_iter
= (atoi (rounds_pos
));
19739 algorithm_pos
= strchr (rounds_pos
, '*');
19741 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19745 keepass
->algorithm
= atoi (algorithm_pos
);
19747 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19749 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19751 final_random_seed_pos
++;
19753 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19754 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19755 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19756 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19758 if (keepass
->version
== 2)
19760 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19761 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19762 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19763 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19766 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19768 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19770 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19772 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19773 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19775 transf_random_seed_pos
++;
19777 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19778 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19779 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19780 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19781 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19782 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19783 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19784 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19786 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19788 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19790 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19792 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19796 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19797 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19798 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19799 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19801 if (keepass
->version
== 1)
19803 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19805 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19807 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19809 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19811 contents_hash_pos
++;
19813 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19814 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19815 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19816 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19817 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19818 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19819 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19820 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19822 /* get length of contents following */
19823 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19825 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19827 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19829 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19833 u32 inline_flag
= atoi (inline_flag_pos
);
19835 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19837 contents_len_pos
= strchr (inline_flag_pos
, '*');
19839 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19841 contents_len_pos
++;
19843 contents_len
= atoi (contents_len_pos
);
19845 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19847 contents_pos
= strchr (contents_len_pos
, '*');
19849 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19855 keepass
->contents_len
= contents_len
;
19857 contents_len
= contents_len
/ 4;
19859 keyfile_inline_pos
= strchr (contents_pos
, '*');
19861 u32 real_contents_len
;
19863 if (keyfile_inline_pos
== NULL
)
19864 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19867 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19868 keyfile_inline_pos
++;
19869 is_keyfile_present
= 1;
19872 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19874 for (i
= 0; i
< contents_len
; i
++)
19875 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19877 else if (keepass
->version
== 2)
19879 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19881 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19883 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19885 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19887 expected_bytes_pos
++;
19889 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19890 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19891 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19892 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19893 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19894 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19895 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19896 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19898 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19900 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19902 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19904 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19906 contents_hash_pos
++;
19908 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19909 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19910 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19911 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19912 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19913 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19914 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19915 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19917 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19919 if (keyfile_inline_pos
== NULL
)
19920 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19923 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19924 keyfile_inline_pos
++;
19925 is_keyfile_present
= 1;
19927 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19930 if (is_keyfile_present
!= 0)
19932 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19936 keyfile_len
= atoi (keyfile_len_pos
);
19938 keepass
->keyfile_len
= keyfile_len
;
19940 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19942 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19944 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19948 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19950 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19952 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19953 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19954 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19955 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19956 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19957 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19958 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19959 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19962 digest
[0] = keepass
->enc_iv
[0];
19963 digest
[1] = keepass
->enc_iv
[1];
19964 digest
[2] = keepass
->enc_iv
[2];
19965 digest
[3] = keepass
->enc_iv
[3];
19967 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19968 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19969 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19970 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19971 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19972 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19973 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19974 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19976 return (PARSER_OK
);
19979 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19981 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19983 u32
*digest
= (u32
*) hash_buf
->digest
;
19985 salt_t
*salt
= hash_buf
->salt
;
19987 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19988 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19989 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19990 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19991 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19992 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19993 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19994 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19996 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19998 uint salt_len
= input_len
- 64 - 1;
20000 char *salt_buf
= input_buf
+ 64 + 1;
20002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20004 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20006 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20008 salt
->salt_len
= salt_len
;
20011 * we can precompute the first sha256 transform
20014 uint w
[16] = { 0 };
20016 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20017 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20018 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20019 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20020 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20021 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20022 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20023 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20024 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20025 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20026 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20027 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20028 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20029 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20030 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20031 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20033 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20035 sha256_64 (w
, pc256
);
20037 salt
->salt_buf_pc
[0] = pc256
[0];
20038 salt
->salt_buf_pc
[1] = pc256
[1];
20039 salt
->salt_buf_pc
[2] = pc256
[2];
20040 salt
->salt_buf_pc
[3] = pc256
[3];
20041 salt
->salt_buf_pc
[4] = pc256
[4];
20042 salt
->salt_buf_pc
[5] = pc256
[5];
20043 salt
->salt_buf_pc
[6] = pc256
[6];
20044 salt
->salt_buf_pc
[7] = pc256
[7];
20046 digest
[0] -= pc256
[0];
20047 digest
[1] -= pc256
[1];
20048 digest
[2] -= pc256
[2];
20049 digest
[3] -= pc256
[3];
20050 digest
[4] -= pc256
[4];
20051 digest
[5] -= pc256
[5];
20052 digest
[6] -= pc256
[6];
20053 digest
[7] -= pc256
[7];
20055 return (PARSER_OK
);
20058 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20060 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20062 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20064 u32
*digest
= (u32
*) hash_buf
->digest
;
20066 salt_t
*salt
= hash_buf
->salt
;
20072 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20074 char *data_buf_pos
= strchr (data_len_pos
, '$');
20076 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20078 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20080 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20081 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20085 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20087 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20089 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20091 u32 data_len
= atoi (data_len_pos
);
20093 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20099 char *salt_pos
= data_buf_pos
;
20101 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20102 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20103 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20104 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20106 // this is actually the CT, which is also the hash later (if matched)
20108 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20109 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20110 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20111 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20113 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20115 salt
->salt_iter
= 10 - 1;
20121 digest
[0] = salt
->salt_buf
[4];
20122 digest
[1] = salt
->salt_buf
[5];
20123 digest
[2] = salt
->salt_buf
[6];
20124 digest
[3] = salt
->salt_buf
[7];
20126 return (PARSER_OK
);
20129 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20131 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20133 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20135 u32
*digest
= (u32
*) hash_buf
->digest
;
20137 salt_t
*salt
= hash_buf
->salt
;
20143 char *salt_pos
= input_buf
+ 11 + 1;
20145 char *iter_pos
= strchr (salt_pos
, ',');
20147 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20149 u32 salt_len
= iter_pos
- salt_pos
;
20151 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20155 char *hash_pos
= strchr (iter_pos
, ',');
20157 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20159 u32 iter_len
= hash_pos
- iter_pos
;
20161 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20165 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20167 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20173 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20174 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20175 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20176 salt
->salt_buf
[3] = 0x00018000;
20178 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20179 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20180 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20181 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20183 salt
->salt_len
= salt_len
/ 2;
20185 salt
->salt_iter
= atoi (iter_pos
) - 1;
20191 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20192 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20193 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20194 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20195 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20196 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20197 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20198 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20200 return (PARSER_OK
);
20203 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20205 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20207 u32
*digest
= (u32
*) hash_buf
->digest
;
20209 salt_t
*salt
= hash_buf
->salt
;
20215 char *hash_pos
= input_buf
+ 64;
20216 char *salt1_pos
= input_buf
+ 128;
20217 char *salt2_pos
= input_buf
;
20223 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20224 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20225 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20226 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20228 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20229 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20230 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20231 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20233 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20234 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20235 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20236 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20238 salt
->salt_len
= 48;
20240 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20246 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20247 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20248 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20249 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20250 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20251 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20252 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20253 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20255 return (PARSER_OK
);
20258 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20260 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20262 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20263 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20265 u32
*digest
= (u32
*) hash_buf
->digest
;
20267 salt_t
*salt
= hash_buf
->salt
;
20269 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20275 char *param0_pos
= input_buf
+ 6 + 1;
20277 char *param1_pos
= strchr (param0_pos
, '*');
20279 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20281 u32 param0_len
= param1_pos
- param0_pos
;
20285 char *param2_pos
= strchr (param1_pos
, '*');
20287 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20289 u32 param1_len
= param2_pos
- param1_pos
;
20293 char *param3_pos
= strchr (param2_pos
, '*');
20295 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20297 u32 param2_len
= param3_pos
- param2_pos
;
20301 char *param4_pos
= strchr (param3_pos
, '*');
20303 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20305 u32 param3_len
= param4_pos
- param3_pos
;
20309 char *param5_pos
= strchr (param4_pos
, '*');
20311 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20313 u32 param4_len
= param5_pos
- param4_pos
;
20317 char *param6_pos
= strchr (param5_pos
, '*');
20319 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20321 u32 param5_len
= param6_pos
- param5_pos
;
20325 char *param7_pos
= strchr (param6_pos
, '*');
20327 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20329 u32 param6_len
= param7_pos
- param6_pos
;
20333 char *param8_pos
= strchr (param7_pos
, '*');
20335 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20337 u32 param7_len
= param8_pos
- param7_pos
;
20341 const uint type
= atoi (param0_pos
);
20342 const uint mode
= atoi (param1_pos
);
20343 const uint magic
= atoi (param2_pos
);
20345 char *salt_buf
= param3_pos
;
20347 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20349 const uint compress_length
= atoi (param5_pos
);
20351 char *data_buf
= param6_pos
;
20352 char *auth
= param7_pos
;
20358 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20360 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20362 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20364 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20366 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20368 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20370 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20372 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20374 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20376 if (type
!= 0) return (PARSER_SALT_VALUE
);
20378 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20380 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20382 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20390 zip2
->magic
= magic
;
20394 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20395 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20396 zip2
->salt_buf
[2] = 0;
20397 zip2
->salt_buf
[3] = 0;
20399 zip2
->salt_len
= 8;
20401 else if (mode
== 2)
20403 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20404 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20405 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20406 zip2
->salt_buf
[3] = 0;
20408 zip2
->salt_len
= 12;
20410 else if (mode
== 3)
20412 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20413 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20414 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20415 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20417 zip2
->salt_len
= 16;
20420 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20421 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20422 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20423 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20425 zip2
->verify_bytes
= verify_bytes
;
20427 zip2
->compress_length
= compress_length
;
20429 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20431 for (uint i
= 0; i
< param6_len
; i
+= 2)
20433 const char p0
= data_buf
[i
+ 0];
20434 const char p1
= data_buf
[i
+ 1];
20436 *data_buf_ptr
++ = hex_convert (p1
) << 0
20437 | hex_convert (p0
) << 4;
20442 *data_buf_ptr
= 0x80;
20444 char *auth_ptr
= (char *) zip2
->auth_buf
;
20446 for (uint i
= 0; i
< param7_len
; i
+= 2)
20448 const char p0
= auth
[i
+ 0];
20449 const char p1
= auth
[i
+ 1];
20451 *auth_ptr
++ = hex_convert (p1
) << 0
20452 | hex_convert (p0
) << 4;
20461 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20462 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20463 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20464 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20465 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20466 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20467 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20468 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20470 salt
->salt_len
= 32;
20472 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20475 * digest buf (fake)
20478 digest
[0] = zip2
->auth_buf
[0];
20479 digest
[1] = zip2
->auth_buf
[1];
20480 digest
[2] = zip2
->auth_buf
[2];
20481 digest
[3] = zip2
->auth_buf
[3];
20483 return (PARSER_OK
);
20487 * parallel running threads
20492 BOOL WINAPI
sigHandler_default (DWORD sig
)
20496 case CTRL_CLOSE_EVENT
:
20499 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20500 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20501 * function otherwise it is too late (e.g. after returning from this function)
20506 SetConsoleCtrlHandler (NULL
, TRUE
);
20513 case CTRL_LOGOFF_EVENT
:
20514 case CTRL_SHUTDOWN_EVENT
:
20518 SetConsoleCtrlHandler (NULL
, TRUE
);
20526 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20530 case CTRL_CLOSE_EVENT
:
20534 SetConsoleCtrlHandler (NULL
, TRUE
);
20541 case CTRL_LOGOFF_EVENT
:
20542 case CTRL_SHUTDOWN_EVENT
:
20546 SetConsoleCtrlHandler (NULL
, TRUE
);
20554 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20556 if (callback
== NULL
)
20558 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20562 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20568 void sigHandler_default (int sig
)
20572 signal (sig
, NULL
);
20575 void sigHandler_benchmark (int sig
)
20579 signal (sig
, NULL
);
20582 void hc_signal (void (callback
) (int))
20584 if (callback
== NULL
) callback
= SIG_DFL
;
20586 signal (SIGINT
, callback
);
20587 signal (SIGTERM
, callback
);
20588 signal (SIGABRT
, callback
);
20593 void status_display ();
20595 void *thread_keypress (void *p
)
20597 int benchmark
= *((int *) p
);
20599 uint quiet
= data
.quiet
;
20603 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20605 int ch
= tty_getchar();
20607 if (ch
== -1) break;
20609 if (ch
== 0) continue;
20611 //https://github.com/hashcat/hashcat/issues/302
20616 hc_thread_mutex_lock (mux_display
);
20632 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20633 if (quiet
== 0) fflush (stdout
);
20645 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20646 if (quiet
== 0) fflush (stdout
);
20658 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20659 if (quiet
== 0) fflush (stdout
);
20671 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20672 if (quiet
== 0) fflush (stdout
);
20680 if (benchmark
== 1) break;
20682 stop_at_checkpoint ();
20686 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20687 if (quiet
== 0) fflush (stdout
);
20695 if (benchmark
== 1)
20707 //https://github.com/hashcat/hashcat/issues/302
20712 hc_thread_mutex_unlock (mux_display
);
20724 bool class_num (const u8 c
)
20726 return ((c
>= '0') && (c
<= '9'));
20729 bool class_lower (const u8 c
)
20731 return ((c
>= 'a') && (c
<= 'z'));
20734 bool class_upper (const u8 c
)
20736 return ((c
>= 'A') && (c
<= 'Z'));
20739 bool class_alpha (const u8 c
)
20741 return (class_lower (c
) || class_upper (c
));
20744 int conv_ctoi (const u8 c
)
20750 else if (class_upper (c
))
20752 return c
- 'A' + 10;
20758 int conv_itoc (const u8 c
)
20766 return c
+ 'A' - 10;
20776 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20777 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20778 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20779 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20780 #define MAX_KERNEL_RULES 255
20781 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20782 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20783 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20785 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20786 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20787 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20788 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20790 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20795 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20797 switch (rule_buf
[rule_pos
])
20803 case RULE_OP_MANGLE_NOOP
:
20804 SET_NAME (rule
, rule_buf
[rule_pos
]);
20807 case RULE_OP_MANGLE_LREST
:
20808 SET_NAME (rule
, rule_buf
[rule_pos
]);
20811 case RULE_OP_MANGLE_UREST
:
20812 SET_NAME (rule
, rule_buf
[rule_pos
]);
20815 case RULE_OP_MANGLE_LREST_UFIRST
:
20816 SET_NAME (rule
, rule_buf
[rule_pos
]);
20819 case RULE_OP_MANGLE_UREST_LFIRST
:
20820 SET_NAME (rule
, rule_buf
[rule_pos
]);
20823 case RULE_OP_MANGLE_TREST
:
20824 SET_NAME (rule
, rule_buf
[rule_pos
]);
20827 case RULE_OP_MANGLE_TOGGLE_AT
:
20828 SET_NAME (rule
, rule_buf
[rule_pos
]);
20829 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20832 case RULE_OP_MANGLE_REVERSE
:
20833 SET_NAME (rule
, rule_buf
[rule_pos
]);
20836 case RULE_OP_MANGLE_DUPEWORD
:
20837 SET_NAME (rule
, rule_buf
[rule_pos
]);
20840 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20841 SET_NAME (rule
, rule_buf
[rule_pos
]);
20842 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20845 case RULE_OP_MANGLE_REFLECT
:
20846 SET_NAME (rule
, rule_buf
[rule_pos
]);
20849 case RULE_OP_MANGLE_ROTATE_LEFT
:
20850 SET_NAME (rule
, rule_buf
[rule_pos
]);
20853 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20854 SET_NAME (rule
, rule_buf
[rule_pos
]);
20857 case RULE_OP_MANGLE_APPEND
:
20858 SET_NAME (rule
, rule_buf
[rule_pos
]);
20859 SET_P0 (rule
, rule_buf
[rule_pos
]);
20862 case RULE_OP_MANGLE_PREPEND
:
20863 SET_NAME (rule
, rule_buf
[rule_pos
]);
20864 SET_P0 (rule
, rule_buf
[rule_pos
]);
20867 case RULE_OP_MANGLE_DELETE_FIRST
:
20868 SET_NAME (rule
, rule_buf
[rule_pos
]);
20871 case RULE_OP_MANGLE_DELETE_LAST
:
20872 SET_NAME (rule
, rule_buf
[rule_pos
]);
20875 case RULE_OP_MANGLE_DELETE_AT
:
20876 SET_NAME (rule
, rule_buf
[rule_pos
]);
20877 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20880 case RULE_OP_MANGLE_EXTRACT
:
20881 SET_NAME (rule
, rule_buf
[rule_pos
]);
20882 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20883 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20886 case RULE_OP_MANGLE_OMIT
:
20887 SET_NAME (rule
, rule_buf
[rule_pos
]);
20888 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20889 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20892 case RULE_OP_MANGLE_INSERT
:
20893 SET_NAME (rule
, rule_buf
[rule_pos
]);
20894 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20895 SET_P1 (rule
, rule_buf
[rule_pos
]);
20898 case RULE_OP_MANGLE_OVERSTRIKE
:
20899 SET_NAME (rule
, rule_buf
[rule_pos
]);
20900 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20901 SET_P1 (rule
, rule_buf
[rule_pos
]);
20904 case RULE_OP_MANGLE_TRUNCATE_AT
:
20905 SET_NAME (rule
, rule_buf
[rule_pos
]);
20906 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20909 case RULE_OP_MANGLE_REPLACE
:
20910 SET_NAME (rule
, rule_buf
[rule_pos
]);
20911 SET_P0 (rule
, rule_buf
[rule_pos
]);
20912 SET_P1 (rule
, rule_buf
[rule_pos
]);
20915 case RULE_OP_MANGLE_PURGECHAR
:
20919 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20923 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20924 SET_NAME (rule
, rule_buf
[rule_pos
]);
20925 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20928 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20929 SET_NAME (rule
, rule_buf
[rule_pos
]);
20930 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20933 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20934 SET_NAME (rule
, rule_buf
[rule_pos
]);
20937 case RULE_OP_MANGLE_SWITCH_FIRST
:
20938 SET_NAME (rule
, rule_buf
[rule_pos
]);
20941 case RULE_OP_MANGLE_SWITCH_LAST
:
20942 SET_NAME (rule
, rule_buf
[rule_pos
]);
20945 case RULE_OP_MANGLE_SWITCH_AT
:
20946 SET_NAME (rule
, rule_buf
[rule_pos
]);
20947 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20948 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20951 case RULE_OP_MANGLE_CHR_SHIFTL
:
20952 SET_NAME (rule
, rule_buf
[rule_pos
]);
20953 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20956 case RULE_OP_MANGLE_CHR_SHIFTR
:
20957 SET_NAME (rule
, rule_buf
[rule_pos
]);
20958 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20961 case RULE_OP_MANGLE_CHR_INCR
:
20962 SET_NAME (rule
, rule_buf
[rule_pos
]);
20963 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20966 case RULE_OP_MANGLE_CHR_DECR
:
20967 SET_NAME (rule
, rule_buf
[rule_pos
]);
20968 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20971 case RULE_OP_MANGLE_REPLACE_NP1
:
20972 SET_NAME (rule
, rule_buf
[rule_pos
]);
20973 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20976 case RULE_OP_MANGLE_REPLACE_NM1
:
20977 SET_NAME (rule
, rule_buf
[rule_pos
]);
20978 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20981 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20982 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20986 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20987 SET_NAME (rule
, rule_buf
[rule_pos
]);
20988 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20991 case RULE_OP_MANGLE_TITLE
:
20992 SET_NAME (rule
, rule_buf
[rule_pos
]);
21001 if (rule_pos
< rule_len
) return (-1);
21006 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21010 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21014 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21018 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21022 case RULE_OP_MANGLE_NOOP
:
21023 rule_buf
[rule_pos
] = rule_cmd
;
21026 case RULE_OP_MANGLE_LREST
:
21027 rule_buf
[rule_pos
] = rule_cmd
;
21030 case RULE_OP_MANGLE_UREST
:
21031 rule_buf
[rule_pos
] = rule_cmd
;
21034 case RULE_OP_MANGLE_LREST_UFIRST
:
21035 rule_buf
[rule_pos
] = rule_cmd
;
21038 case RULE_OP_MANGLE_UREST_LFIRST
:
21039 rule_buf
[rule_pos
] = rule_cmd
;
21042 case RULE_OP_MANGLE_TREST
:
21043 rule_buf
[rule_pos
] = rule_cmd
;
21046 case RULE_OP_MANGLE_TOGGLE_AT
:
21047 rule_buf
[rule_pos
] = rule_cmd
;
21048 GET_P0_CONV (rule
);
21051 case RULE_OP_MANGLE_REVERSE
:
21052 rule_buf
[rule_pos
] = rule_cmd
;
21055 case RULE_OP_MANGLE_DUPEWORD
:
21056 rule_buf
[rule_pos
] = rule_cmd
;
21059 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21060 rule_buf
[rule_pos
] = rule_cmd
;
21061 GET_P0_CONV (rule
);
21064 case RULE_OP_MANGLE_REFLECT
:
21065 rule_buf
[rule_pos
] = rule_cmd
;
21068 case RULE_OP_MANGLE_ROTATE_LEFT
:
21069 rule_buf
[rule_pos
] = rule_cmd
;
21072 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21073 rule_buf
[rule_pos
] = rule_cmd
;
21076 case RULE_OP_MANGLE_APPEND
:
21077 rule_buf
[rule_pos
] = rule_cmd
;
21081 case RULE_OP_MANGLE_PREPEND
:
21082 rule_buf
[rule_pos
] = rule_cmd
;
21086 case RULE_OP_MANGLE_DELETE_FIRST
:
21087 rule_buf
[rule_pos
] = rule_cmd
;
21090 case RULE_OP_MANGLE_DELETE_LAST
:
21091 rule_buf
[rule_pos
] = rule_cmd
;
21094 case RULE_OP_MANGLE_DELETE_AT
:
21095 rule_buf
[rule_pos
] = rule_cmd
;
21096 GET_P0_CONV (rule
);
21099 case RULE_OP_MANGLE_EXTRACT
:
21100 rule_buf
[rule_pos
] = rule_cmd
;
21101 GET_P0_CONV (rule
);
21102 GET_P1_CONV (rule
);
21105 case RULE_OP_MANGLE_OMIT
:
21106 rule_buf
[rule_pos
] = rule_cmd
;
21107 GET_P0_CONV (rule
);
21108 GET_P1_CONV (rule
);
21111 case RULE_OP_MANGLE_INSERT
:
21112 rule_buf
[rule_pos
] = rule_cmd
;
21113 GET_P0_CONV (rule
);
21117 case RULE_OP_MANGLE_OVERSTRIKE
:
21118 rule_buf
[rule_pos
] = rule_cmd
;
21119 GET_P0_CONV (rule
);
21123 case RULE_OP_MANGLE_TRUNCATE_AT
:
21124 rule_buf
[rule_pos
] = rule_cmd
;
21125 GET_P0_CONV (rule
);
21128 case RULE_OP_MANGLE_REPLACE
:
21129 rule_buf
[rule_pos
] = rule_cmd
;
21134 case RULE_OP_MANGLE_PURGECHAR
:
21138 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21142 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21143 rule_buf
[rule_pos
] = rule_cmd
;
21144 GET_P0_CONV (rule
);
21147 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21148 rule_buf
[rule_pos
] = rule_cmd
;
21149 GET_P0_CONV (rule
);
21152 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21153 rule_buf
[rule_pos
] = rule_cmd
;
21156 case RULE_OP_MANGLE_SWITCH_FIRST
:
21157 rule_buf
[rule_pos
] = rule_cmd
;
21160 case RULE_OP_MANGLE_SWITCH_LAST
:
21161 rule_buf
[rule_pos
] = rule_cmd
;
21164 case RULE_OP_MANGLE_SWITCH_AT
:
21165 rule_buf
[rule_pos
] = rule_cmd
;
21166 GET_P0_CONV (rule
);
21167 GET_P1_CONV (rule
);
21170 case RULE_OP_MANGLE_CHR_SHIFTL
:
21171 rule_buf
[rule_pos
] = rule_cmd
;
21172 GET_P0_CONV (rule
);
21175 case RULE_OP_MANGLE_CHR_SHIFTR
:
21176 rule_buf
[rule_pos
] = rule_cmd
;
21177 GET_P0_CONV (rule
);
21180 case RULE_OP_MANGLE_CHR_INCR
:
21181 rule_buf
[rule_pos
] = rule_cmd
;
21182 GET_P0_CONV (rule
);
21185 case RULE_OP_MANGLE_CHR_DECR
:
21186 rule_buf
[rule_pos
] = rule_cmd
;
21187 GET_P0_CONV (rule
);
21190 case RULE_OP_MANGLE_REPLACE_NP1
:
21191 rule_buf
[rule_pos
] = rule_cmd
;
21192 GET_P0_CONV (rule
);
21195 case RULE_OP_MANGLE_REPLACE_NM1
:
21196 rule_buf
[rule_pos
] = rule_cmd
;
21197 GET_P0_CONV (rule
);
21200 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21201 rule_buf
[rule_pos
] = rule_cmd
;
21202 GET_P0_CONV (rule
);
21205 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21206 rule_buf
[rule_pos
] = rule_cmd
;
21207 GET_P0_CONV (rule
);
21210 case RULE_OP_MANGLE_TITLE
:
21211 rule_buf
[rule_pos
] = rule_cmd
;
21215 return rule_pos
- 1;
21233 * CPU rules : this is from hashcat sources, cpu based rules
21236 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21237 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21239 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21240 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21241 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21243 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21244 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21245 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21247 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21251 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21256 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21260 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21265 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21269 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21274 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21279 for (l
= 0; l
< arr_len
; l
++)
21281 r
= arr_len
- 1 - l
;
21285 MANGLE_SWITCH (arr
, l
, r
);
21291 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21293 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21295 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21297 return (arr_len
* 2);
21300 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21302 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21304 int orig_len
= arr_len
;
21308 for (i
= 0; i
< times
; i
++)
21310 memcpy (&arr
[arr_len
], arr
, orig_len
);
21312 arr_len
+= orig_len
;
21318 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21320 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21322 mangle_double (arr
, arr_len
);
21324 mangle_reverse (arr
+ arr_len
, arr_len
);
21326 return (arr_len
* 2);
21329 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21334 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21336 MANGLE_SWITCH (arr
, l
, r
);
21342 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21347 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21349 MANGLE_SWITCH (arr
, l
, r
);
21355 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21357 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21361 return (arr_len
+ 1);
21364 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21366 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21370 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21372 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21377 return (arr_len
+ 1);
21380 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21382 if (upos
>= arr_len
) return (arr_len
);
21386 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21388 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21391 return (arr_len
- 1);
21394 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21396 if (upos
>= arr_len
) return (arr_len
);
21398 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21402 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21404 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21410 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21412 if (upos
>= arr_len
) return (arr_len
);
21414 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21418 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21420 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21423 return (arr_len
- ulen
);
21426 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21428 if (upos
>= arr_len
) return (arr_len
);
21430 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21434 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21436 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21441 return (arr_len
+ 1);
21444 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
)
21446 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21448 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21450 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21452 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21454 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21456 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21458 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21460 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21462 return (arr_len
+ arr2_cpy
);
21465 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21467 if (upos
>= arr_len
) return (arr_len
);
21474 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21476 if (upos
>= arr_len
) return (arr_len
);
21478 memset (arr
+ upos
, 0, arr_len
- upos
);
21483 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21487 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21489 if (arr
[arr_pos
] != oldc
) continue;
21491 arr
[arr_pos
] = newc
;
21497 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21503 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21505 if (arr
[arr_pos
] == c
) continue;
21507 arr
[ret_len
] = arr
[arr_pos
];
21515 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21517 if (ulen
> arr_len
) return (arr_len
);
21519 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21521 char cs
[100] = { 0 };
21523 memcpy (cs
, arr
, ulen
);
21527 for (i
= 0; i
< ulen
; i
++)
21531 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21537 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21539 if (ulen
> arr_len
) return (arr_len
);
21541 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21543 int upos
= arr_len
- ulen
;
21547 for (i
= 0; i
< ulen
; i
++)
21549 char c
= arr
[upos
+ i
];
21551 arr_len
= mangle_append (arr
, arr_len
, c
);
21557 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21559 if ( arr_len
== 0) return (arr_len
);
21560 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21562 char c
= arr
[upos
];
21566 for (i
= 0; i
< ulen
; i
++)
21568 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21574 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21576 if ( arr_len
== 0) return (arr_len
);
21577 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21581 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21583 int new_pos
= arr_pos
* 2;
21585 arr
[new_pos
] = arr
[arr_pos
];
21587 arr
[new_pos
+ 1] = arr
[arr_pos
];
21590 return (arr_len
* 2);
21593 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21595 if (upos
>= arr_len
) return (arr_len
);
21596 if (upos2
>= arr_len
) return (arr_len
);
21598 MANGLE_SWITCH (arr
, upos
, upos2
);
21603 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21605 MANGLE_SWITCH (arr
, upos
, upos2
);
21610 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21612 if (upos
>= arr_len
) return (arr_len
);
21619 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21621 if (upos
>= arr_len
) return (arr_len
);
21628 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21630 if (upos
>= arr_len
) return (arr_len
);
21637 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21639 if (upos
>= arr_len
) return (arr_len
);
21646 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21648 int upper_next
= 1;
21652 for (pos
= 0; pos
< arr_len
; pos
++)
21654 if (arr
[pos
] == ' ')
21665 MANGLE_UPPER_AT (arr
, pos
);
21669 MANGLE_LOWER_AT (arr
, pos
);
21676 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21678 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21684 for (j
= 0; j
< rp_gen_num
; j
++)
21691 switch ((char) get_random_num (0, 9))
21694 r
= get_random_num (0, sizeof (grp_op_nop
));
21695 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21699 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21700 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21701 p1
= get_random_num (0, sizeof (grp_pos
));
21702 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21706 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21707 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21708 p1
= get_random_num (1, 6);
21709 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21713 r
= get_random_num (0, sizeof (grp_op_chr
));
21714 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21715 p1
= get_random_num (0x20, 0x7e);
21716 rule_buf
[rule_pos
++] = (char) p1
;
21720 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21721 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21722 p1
= get_random_num (0x20, 0x7e);
21723 rule_buf
[rule_pos
++] = (char) p1
;
21724 p2
= get_random_num (0x20, 0x7e);
21726 p2
= get_random_num (0x20, 0x7e);
21727 rule_buf
[rule_pos
++] = (char) p2
;
21731 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21732 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21733 p1
= get_random_num (0, sizeof (grp_pos
));
21734 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21735 p2
= get_random_num (0x20, 0x7e);
21736 rule_buf
[rule_pos
++] = (char) p2
;
21740 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21741 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21742 p1
= get_random_num (0, sizeof (grp_pos
));
21743 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21744 p2
= get_random_num (0, sizeof (grp_pos
));
21746 p2
= get_random_num (0, sizeof (grp_pos
));
21747 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21751 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21752 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21753 p1
= get_random_num (0, sizeof (grp_pos
));
21754 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21755 p2
= get_random_num (1, sizeof (grp_pos
));
21757 p2
= get_random_num (1, sizeof (grp_pos
));
21758 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21762 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21763 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21764 p1
= get_random_num (0, sizeof (grp_pos
));
21765 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21766 p2
= get_random_num (1, sizeof (grp_pos
));
21767 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21768 p3
= get_random_num (0, sizeof (grp_pos
));
21769 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21777 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21779 char mem
[BLOCK_SIZE
] = { 0 };
21781 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21783 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21785 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21787 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21789 int out_len
= in_len
;
21790 int mem_len
= in_len
;
21792 memcpy (out
, in
, out_len
);
21796 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21801 switch (rule
[rule_pos
])
21806 case RULE_OP_MANGLE_NOOP
:
21809 case RULE_OP_MANGLE_LREST
:
21810 out_len
= mangle_lrest (out
, out_len
);
21813 case RULE_OP_MANGLE_UREST
:
21814 out_len
= mangle_urest (out
, out_len
);
21817 case RULE_OP_MANGLE_LREST_UFIRST
:
21818 out_len
= mangle_lrest (out
, out_len
);
21819 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21822 case RULE_OP_MANGLE_UREST_LFIRST
:
21823 out_len
= mangle_urest (out
, out_len
);
21824 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21827 case RULE_OP_MANGLE_TREST
:
21828 out_len
= mangle_trest (out
, out_len
);
21831 case RULE_OP_MANGLE_TOGGLE_AT
:
21832 NEXT_RULEPOS (rule_pos
);
21833 NEXT_RPTOI (rule
, rule_pos
, upos
);
21834 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21837 case RULE_OP_MANGLE_REVERSE
:
21838 out_len
= mangle_reverse (out
, out_len
);
21841 case RULE_OP_MANGLE_DUPEWORD
:
21842 out_len
= mangle_double (out
, out_len
);
21845 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21846 NEXT_RULEPOS (rule_pos
);
21847 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21848 out_len
= mangle_double_times (out
, out_len
, ulen
);
21851 case RULE_OP_MANGLE_REFLECT
:
21852 out_len
= mangle_reflect (out
, out_len
);
21855 case RULE_OP_MANGLE_ROTATE_LEFT
:
21856 mangle_rotate_left (out
, out_len
);
21859 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21860 mangle_rotate_right (out
, out_len
);
21863 case RULE_OP_MANGLE_APPEND
:
21864 NEXT_RULEPOS (rule_pos
);
21865 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21868 case RULE_OP_MANGLE_PREPEND
:
21869 NEXT_RULEPOS (rule_pos
);
21870 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21873 case RULE_OP_MANGLE_DELETE_FIRST
:
21874 out_len
= mangle_delete_at (out
, out_len
, 0);
21877 case RULE_OP_MANGLE_DELETE_LAST
:
21878 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21881 case RULE_OP_MANGLE_DELETE_AT
:
21882 NEXT_RULEPOS (rule_pos
);
21883 NEXT_RPTOI (rule
, rule_pos
, upos
);
21884 out_len
= mangle_delete_at (out
, out_len
, upos
);
21887 case RULE_OP_MANGLE_EXTRACT
:
21888 NEXT_RULEPOS (rule_pos
);
21889 NEXT_RPTOI (rule
, rule_pos
, upos
);
21890 NEXT_RULEPOS (rule_pos
);
21891 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21892 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21895 case RULE_OP_MANGLE_OMIT
:
21896 NEXT_RULEPOS (rule_pos
);
21897 NEXT_RPTOI (rule
, rule_pos
, upos
);
21898 NEXT_RULEPOS (rule_pos
);
21899 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21900 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21903 case RULE_OP_MANGLE_INSERT
:
21904 NEXT_RULEPOS (rule_pos
);
21905 NEXT_RPTOI (rule
, rule_pos
, upos
);
21906 NEXT_RULEPOS (rule_pos
);
21907 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21910 case RULE_OP_MANGLE_OVERSTRIKE
:
21911 NEXT_RULEPOS (rule_pos
);
21912 NEXT_RPTOI (rule
, rule_pos
, upos
);
21913 NEXT_RULEPOS (rule_pos
);
21914 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21917 case RULE_OP_MANGLE_TRUNCATE_AT
:
21918 NEXT_RULEPOS (rule_pos
);
21919 NEXT_RPTOI (rule
, rule_pos
, upos
);
21920 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21923 case RULE_OP_MANGLE_REPLACE
:
21924 NEXT_RULEPOS (rule_pos
);
21925 NEXT_RULEPOS (rule_pos
);
21926 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21929 case RULE_OP_MANGLE_PURGECHAR
:
21930 NEXT_RULEPOS (rule_pos
);
21931 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21934 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21938 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21939 NEXT_RULEPOS (rule_pos
);
21940 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21941 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21944 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21945 NEXT_RULEPOS (rule_pos
);
21946 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21947 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21950 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21951 out_len
= mangle_dupechar (out
, out_len
);
21954 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21955 NEXT_RULEPOS (rule_pos
);
21956 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21957 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21960 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21961 NEXT_RULEPOS (rule_pos
);
21962 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21963 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21966 case RULE_OP_MANGLE_SWITCH_FIRST
:
21967 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21970 case RULE_OP_MANGLE_SWITCH_LAST
:
21971 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21974 case RULE_OP_MANGLE_SWITCH_AT
:
21975 NEXT_RULEPOS (rule_pos
);
21976 NEXT_RPTOI (rule
, rule_pos
, upos
);
21977 NEXT_RULEPOS (rule_pos
);
21978 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21979 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21982 case RULE_OP_MANGLE_CHR_SHIFTL
:
21983 NEXT_RULEPOS (rule_pos
);
21984 NEXT_RPTOI (rule
, rule_pos
, upos
);
21985 mangle_chr_shiftl (out
, out_len
, upos
);
21988 case RULE_OP_MANGLE_CHR_SHIFTR
:
21989 NEXT_RULEPOS (rule_pos
);
21990 NEXT_RPTOI (rule
, rule_pos
, upos
);
21991 mangle_chr_shiftr (out
, out_len
, upos
);
21994 case RULE_OP_MANGLE_CHR_INCR
:
21995 NEXT_RULEPOS (rule_pos
);
21996 NEXT_RPTOI (rule
, rule_pos
, upos
);
21997 mangle_chr_incr (out
, out_len
, upos
);
22000 case RULE_OP_MANGLE_CHR_DECR
:
22001 NEXT_RULEPOS (rule_pos
);
22002 NEXT_RPTOI (rule
, rule_pos
, upos
);
22003 mangle_chr_decr (out
, out_len
, upos
);
22006 case RULE_OP_MANGLE_REPLACE_NP1
:
22007 NEXT_RULEPOS (rule_pos
);
22008 NEXT_RPTOI (rule
, rule_pos
, upos
);
22009 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22012 case RULE_OP_MANGLE_REPLACE_NM1
:
22013 NEXT_RULEPOS (rule_pos
);
22014 NEXT_RPTOI (rule
, rule_pos
, upos
);
22015 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22018 case RULE_OP_MANGLE_TITLE
:
22019 out_len
= mangle_title (out
, out_len
);
22022 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22023 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22024 NEXT_RULEPOS (rule_pos
);
22025 NEXT_RPTOI (rule
, rule_pos
, upos
);
22026 NEXT_RULEPOS (rule_pos
);
22027 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22028 NEXT_RULEPOS (rule_pos
);
22029 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22030 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22033 case RULE_OP_MANGLE_APPEND_MEMORY
:
22034 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22035 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22036 memcpy (out
+ out_len
, mem
, mem_len
);
22037 out_len
+= mem_len
;
22040 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22041 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22042 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22043 memcpy (mem
+ mem_len
, out
, out_len
);
22044 out_len
+= mem_len
;
22045 memcpy (out
, mem
, out_len
);
22048 case RULE_OP_MEMORIZE_WORD
:
22049 memcpy (mem
, out
, out_len
);
22053 case RULE_OP_REJECT_LESS
:
22054 NEXT_RULEPOS (rule_pos
);
22055 NEXT_RPTOI (rule
, rule_pos
, upos
);
22056 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22059 case RULE_OP_REJECT_GREATER
:
22060 NEXT_RULEPOS (rule_pos
);
22061 NEXT_RPTOI (rule
, rule_pos
, upos
);
22062 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22065 case RULE_OP_REJECT_CONTAIN
:
22066 NEXT_RULEPOS (rule_pos
);
22067 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22070 case RULE_OP_REJECT_NOT_CONTAIN
:
22071 NEXT_RULEPOS (rule_pos
);
22072 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22075 case RULE_OP_REJECT_EQUAL_FIRST
:
22076 NEXT_RULEPOS (rule_pos
);
22077 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22080 case RULE_OP_REJECT_EQUAL_LAST
:
22081 NEXT_RULEPOS (rule_pos
);
22082 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22085 case RULE_OP_REJECT_EQUAL_AT
:
22086 NEXT_RULEPOS (rule_pos
);
22087 NEXT_RPTOI (rule
, rule_pos
, upos
);
22088 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22089 NEXT_RULEPOS (rule_pos
);
22090 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22093 case RULE_OP_REJECT_CONTAINS
:
22094 NEXT_RULEPOS (rule_pos
);
22095 NEXT_RPTOI (rule
, rule_pos
, upos
);
22096 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22097 NEXT_RULEPOS (rule_pos
);
22098 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22099 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22102 case RULE_OP_REJECT_MEMORY
:
22103 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22107 return (RULE_RC_SYNTAX_ERROR
);
22112 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);