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;
3065 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3073 else if (data
.hm_device
[device_id
].od_version
== 6)
3075 int CurrentValue
= 0;
3076 int DefaultValue
= 0;
3078 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3080 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3082 return DefaultValue
;
3088 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3089 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3091 #if defined(LINUX) && defined(HAVE_NVML)
3094 hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
);
3099 #if defined(WIN) && defined(HAVE_NVAPI)
3101 #endif // WIN && HAVE_NVAPI
3103 #endif // HAVE_NVML || HAVE_NVAPI
3108 int hm_get_temperature_with_device_id (const uint device_id
)
3110 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3113 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3117 if (data
.hm_device
[device_id
].od_version
== 5)
3119 ADLTemperature Temperature
;
3121 Temperature
.iSize
= sizeof (ADLTemperature
);
3123 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3125 return Temperature
.iTemperature
/ 1000;
3127 else if (data
.hm_device
[device_id
].od_version
== 6)
3129 int Temperature
= 0;
3131 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3133 return Temperature
/ 1000;
3139 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3140 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3142 #if defined(LINUX) && defined(HAVE_NVML)
3143 int temperature
= 0;
3145 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3150 #if defined(WIN) && defined(HAVE_NVAPI)
3151 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3153 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3154 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3155 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3156 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3158 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3160 return pThermalSettings
.sensor
[0].currentTemp
;
3161 #endif // WIN && HAVE_NVAPI
3163 #endif // HAVE_NVML || HAVE_NVAPI
3168 int hm_get_fanspeed_with_device_id (const uint device_id
)
3170 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3171 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3173 if (data
.hm_device
[device_id
].fan_supported
== 1)
3176 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3180 if (data
.hm_device
[device_id
].od_version
== 5)
3182 ADLFanSpeedValue lpFanSpeedValue
;
3184 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3186 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3187 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3188 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3190 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3192 return lpFanSpeedValue
.iFanSpeed
;
3194 else // od_version == 6
3196 ADLOD6FanSpeedInfo faninfo
;
3198 memset (&faninfo
, 0, sizeof (faninfo
));
3200 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3202 return faninfo
.iFanSpeedPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3214 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3222 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3224 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3226 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_get_buslanes_with_device_id (const uint device_id
)
3237 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3240 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3244 ADLPMActivity PMActivity
;
3246 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3248 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3250 return PMActivity
.iCurrentBusLanes
;
3255 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3256 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3258 #if defined(LINUX) && defined(HAVE_NVML)
3259 unsigned int currLinkWidth
;
3261 hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &currLinkWidth
);
3263 return currLinkWidth
;
3266 #if defined(WIN) && defined(HAVE_NVAPI)
3269 if (hm_NvAPI_GPU_GetCurrentPCIEDownstreamWidth (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, (NvU32
*) &Width
) != NVAPI_OK
) return -1;
3274 #endif // HAVE_NVML || HAVE_NVAPI
3279 int hm_get_utilization_with_device_id (const uint device_id
)
3281 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3284 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3288 ADLPMActivity PMActivity
;
3290 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3292 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3294 return PMActivity
.iActivityPercent
;
3299 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3300 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3302 #if defined(LINUX) && defined(HAVE_NVML)
3303 nvmlUtilization_t utilization
;
3305 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3307 return utilization
.gpu
;
3310 #if defined(WIN) && defined(HAVE_NVAPI)
3311 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3313 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3315 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3317 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3320 #endif // HAVE_NVML || HAVE_NVAPI
3325 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3327 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3330 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3334 ADLPMActivity PMActivity
;
3336 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3338 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3340 return PMActivity
.iMemoryClock
/ 100;
3345 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3348 #if defined(LINUX) && defined(HAVE_NVML)
3351 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3356 #if defined(WIN) && defined(HAVE_NVAPI)
3357 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3359 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3360 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3362 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3364 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_MEMORY
].frequency
/ 1000;
3367 #endif // HAVE_NVML || HAVE_NVAPI
3372 int hm_get_corespeed_with_device_id (const uint device_id
)
3374 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3377 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3381 ADLPMActivity PMActivity
;
3383 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3385 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3387 return PMActivity
.iEngineClock
/ 100;
3392 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3393 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3395 #if defined(LINUX) && defined(HAVE_NVML)
3398 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3403 #if defined(WIN) && defined(HAVE_NVAPI)
3404 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3406 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3407 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3409 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3411 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS
].frequency
/ 1000;
3414 #endif // HAVE_NVML || HAVE_NVAPI
3420 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3422 if (data
.hm_device
[device_id
].fan_supported
== 1)
3426 if (data
.hm_device
[device_id
].od_version
== 5)
3428 ADLFanSpeedValue lpFanSpeedValue
;
3430 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3432 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3433 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3434 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3435 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3437 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3441 else // od_version == 6
3443 ADLOD6FanSpeedValue fan_speed_value
;
3445 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3447 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3448 fan_speed_value
.iFanSpeed
= fanspeed
;
3450 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3461 // helper function for status display
3463 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3465 #define VALUE_NOT_AVAILABLE "N/A"
3469 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3473 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3476 #endif // HAVE_HWMON
3482 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3484 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3486 if (css_cnt
> SP_PW_MAX
)
3488 log_error ("ERROR: mask length is too long");
3493 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3495 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3497 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3498 uint cs_len
= css
[css_pos
].cs_len
;
3500 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3502 uint c
= cs_buf
[cs_pos
] & 0xff;
3509 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3511 cs_t
*cs
= &css
[css_cnt
];
3513 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3515 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3519 for (i
= 0; i
< cs
->cs_len
; i
++)
3521 const uint u
= cs
->cs_buf
[i
];
3526 for (i
= 0; i
< in_len
; i
++)
3528 uint u
= in_buf
[i
] & 0xff;
3530 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3532 if (css_uniq
[u
] == 1) continue;
3536 cs
->cs_buf
[cs
->cs_len
] = u
;
3544 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3548 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3550 uint p0
= in_buf
[in_pos
] & 0xff;
3552 if (interpret
== 1 && p0
== '?')
3556 if (in_pos
== in_len
) break;
3558 uint p1
= in_buf
[in_pos
] & 0xff;
3562 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3564 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3566 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3568 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3570 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3572 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3574 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3575 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3577 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3578 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3580 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3581 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3583 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3584 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3586 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3588 default: log_error ("Syntax error: %s", in_buf
);
3594 if (data
.hex_charset
)
3598 if (in_pos
== in_len
)
3600 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3605 uint p1
= in_buf
[in_pos
] & 0xff;
3607 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3609 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3616 chr
= hex_convert (p1
) << 0;
3617 chr
|= hex_convert (p0
) << 4;
3619 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3625 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3631 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3635 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3637 sum
*= css
[css_pos
].cs_len
;
3643 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3645 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3650 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3652 char p0
= mask_buf
[mask_pos
];
3658 if (mask_pos
== mask_len
) break;
3660 char p1
= mask_buf
[mask_pos
];
3666 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3668 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3670 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3672 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3674 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3676 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3678 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3679 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3681 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3682 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3684 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3685 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3687 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3688 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3690 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3692 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3698 if (data
.hex_charset
)
3702 // if there is no 2nd hex character, show an error:
3704 if (mask_pos
== mask_len
)
3706 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3711 char p1
= mask_buf
[mask_pos
];
3713 // if they are not valid hex character, show an error:
3715 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3717 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3724 chr
|= hex_convert (p1
) << 0;
3725 chr
|= hex_convert (p0
) << 4;
3727 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3733 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3740 log_error ("ERROR: invalid mask length (0)");
3750 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3752 for (int i
= 0; i
< css_cnt
; i
++)
3754 uint len
= css
[i
].cs_len
;
3755 u64 next
= val
/ len
;
3756 uint pos
= val
% len
;
3757 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3762 void mp_cut_at (char *mask
, uint max
)
3766 uint mask_len
= strlen (mask
);
3768 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3770 if (mask
[i
] == '?') i
++;
3776 void mp_setup_sys (cs_t
*mp_sys
)
3780 uint donec
[CHARSIZ
] = { 0 };
3782 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3783 mp_sys
[0].cs_buf
[pos
++] = chr
;
3784 mp_sys
[0].cs_len
= pos
; }
3786 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3787 mp_sys
[1].cs_buf
[pos
++] = chr
;
3788 mp_sys
[1].cs_len
= pos
; }
3790 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3791 mp_sys
[2].cs_buf
[pos
++] = chr
;
3792 mp_sys
[2].cs_len
= pos
; }
3794 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3795 mp_sys
[3].cs_buf
[pos
++] = chr
;
3796 mp_sys
[3].cs_len
= pos
; }
3798 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3799 mp_sys
[4].cs_len
= pos
; }
3801 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3802 mp_sys
[5].cs_len
= pos
; }
3805 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3807 FILE *fp
= fopen (buf
, "rb");
3809 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3811 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3815 char mp_file
[1024] = { 0 };
3817 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3821 len
= in_superchop (mp_file
);
3825 log_info ("WARNING: charset file corrupted");
3827 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3831 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3836 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3838 mp_usr
[index
].cs_len
= 0;
3840 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3843 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3845 char *new_mask_buf
= (char *) mymalloc (256);
3851 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3853 if (css_pos
== len
) break;
3855 char p0
= mask_buf
[mask_pos
];
3857 new_mask_buf
[mask_pos
] = p0
;
3863 if (mask_pos
== mask_len
) break;
3865 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3869 if (data
.hex_charset
)
3873 if (mask_pos
== mask_len
)
3875 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3880 char p1
= mask_buf
[mask_pos
];
3882 // if they are not valid hex character, show an error:
3884 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3886 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3891 new_mask_buf
[mask_pos
] = p1
;
3896 if (css_pos
== len
) return (new_mask_buf
);
3898 myfree (new_mask_buf
);
3907 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3913 for (i
= start
; i
< stop
; i
++)
3915 sum
*= root_css_buf
[i
].cs_len
;
3921 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3925 cs_t
*cs
= &root_css_buf
[start
];
3929 for (i
= start
; i
< stop
; i
++)
3931 const u64 m
= v
% cs
->cs_len
;
3932 const u64 d
= v
/ cs
->cs_len
;
3936 const uint k
= cs
->cs_buf
[m
];
3938 pw_buf
[i
- start
] = (char) k
;
3940 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3944 int sp_comp_val (const void *p1
, const void *p2
)
3946 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3947 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3949 return b2
->val
- b1
->val
;
3952 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
)
3959 * Initialize hcstats
3962 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3964 u64
*root_stats_ptr
= root_stats_buf
;
3966 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3968 for (i
= 0; i
< SP_PW_MAX
; i
++)
3970 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3972 root_stats_ptr
+= CHARSIZ
;
3975 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3977 u64
*markov_stats_ptr
= markov_stats_buf
;
3979 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3981 for (i
= 0; i
< SP_PW_MAX
; i
++)
3983 for (j
= 0; j
< CHARSIZ
; j
++)
3985 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3987 markov_stats_ptr
+= CHARSIZ
;
3997 char hcstat_tmp
[256] = { 0 };
3999 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4001 hcstat
= hcstat_tmp
;
4004 FILE *fd
= fopen (hcstat
, "rb");
4008 log_error ("%s: %s", hcstat
, strerror (errno
));
4013 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4015 log_error ("%s: Could not load data", hcstat
);
4022 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4024 log_error ("%s: Could not load data", hcstat
);
4034 * Markov modifier of hcstat_table on user request
4039 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4040 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4045 /* Add all stats to first position */
4047 for (i
= 1; i
< SP_PW_MAX
; i
++)
4049 u64
*out
= root_stats_buf_by_pos
[0];
4050 u64
*in
= root_stats_buf_by_pos
[i
];
4052 for (j
= 0; j
< CHARSIZ
; j
++)
4058 for (i
= 1; i
< SP_PW_MAX
; i
++)
4060 u64
*out
= markov_stats_buf_by_key
[0][0];
4061 u64
*in
= markov_stats_buf_by_key
[i
][0];
4063 for (j
= 0; j
< CHARSIZ
; j
++)
4065 for (k
= 0; k
< CHARSIZ
; k
++)
4072 /* copy them to all pw_positions */
4074 for (i
= 1; i
< SP_PW_MAX
; i
++)
4076 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4079 for (i
= 1; i
< SP_PW_MAX
; i
++)
4081 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4089 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4091 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4093 for (i
= 0; i
< SP_PW_MAX
; i
++)
4095 root_table_buf_by_pos
[i
] = root_table_ptr
;
4097 root_table_ptr
+= CHARSIZ
;
4100 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4102 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4104 for (i
= 0; i
< SP_PW_MAX
; i
++)
4106 for (j
= 0; j
< CHARSIZ
; j
++)
4108 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4110 markov_table_ptr
+= CHARSIZ
;
4115 * Convert hcstat to tables
4118 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4120 uint key
= i
% CHARSIZ
;
4122 root_table_buf
[i
].key
= key
;
4123 root_table_buf
[i
].val
= root_stats_buf
[i
];
4126 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4128 uint key
= i
% CHARSIZ
;
4130 markov_table_buf
[i
].key
= key
;
4131 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4134 myfree (root_stats_buf
);
4135 myfree (markov_stats_buf
);
4141 for (i
= 0; i
< SP_PW_MAX
; i
++)
4143 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4146 for (i
= 0; i
< SP_PW_MAX
; i
++)
4148 for (j
= 0; j
< CHARSIZ
; j
++)
4150 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4155 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
])
4158 * Convert tables to css
4161 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4163 uint pw_pos
= i
/ CHARSIZ
;
4165 cs_t
*cs
= &root_css_buf
[pw_pos
];
4167 if (cs
->cs_len
== threshold
) continue;
4169 uint key
= root_table_buf
[i
].key
;
4171 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4173 cs
->cs_buf
[cs
->cs_len
] = key
;
4179 * Convert table to css
4182 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4184 uint c
= i
/ CHARSIZ
;
4186 cs_t
*cs
= &markov_css_buf
[c
];
4188 if (cs
->cs_len
== threshold
) continue;
4190 uint pw_pos
= c
/ CHARSIZ
;
4192 uint key
= markov_table_buf
[i
].key
;
4194 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4196 cs
->cs_buf
[cs
->cs_len
] = key
;
4202 for (uint i = 0; i < 8; i++)
4204 for (uint j = 0x20; j < 0x80; j++)
4206 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4208 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4210 for (uint k = 0; k < 10; k++)
4212 printf (" %u\n", ptr->cs_buf[k]);
4219 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4221 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4223 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4233 for (uint j
= 1; j
< CHARSIZ
; j
++)
4243 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4245 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4247 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4249 out
+= CHARSIZ
* CHARSIZ
;
4250 in
+= CHARSIZ
* CHARSIZ
;
4252 for (uint j
= 0; j
< CHARSIZ
; j
++)
4259 for (uint k
= 1; k
< CHARSIZ
; k
++)
4271 * mixed shared functions
4274 void dump_hex (const u8
*s
, const int sz
)
4276 for (int i
= 0; i
< sz
; i
++)
4278 log_info_nn ("%02x ", s
[i
]);
4284 void usage_mini_print (const char *progname
)
4286 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4289 void usage_big_print (const char *progname
)
4291 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4294 char *get_exec_path ()
4296 int exec_path_len
= 1024;
4298 char *exec_path
= (char *) mymalloc (exec_path_len
);
4302 char tmp
[32] = { 0 };
4304 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4306 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4310 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4314 uint size
= exec_path_len
;
4316 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4318 log_error("! executable path buffer too small\n");
4323 const int len
= strlen (exec_path
);
4326 #error Your Operating System is not supported or detected
4334 char *get_install_dir (const char *progname
)
4336 char *install_dir
= mystrdup (progname
);
4337 char *last_slash
= NULL
;
4339 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4343 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4349 install_dir
[0] = '.';
4353 return (install_dir
);
4356 char *get_profile_dir (const char *homedir
)
4358 #define DOT_HASHCAT ".hashcat"
4360 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4362 char *profile_dir
= (char *) mymalloc (len
+ 1);
4364 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4369 char *get_session_dir (const char *profile_dir
)
4371 #define SESSIONS_FOLDER "sessions"
4373 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4375 char *session_dir
= (char *) mymalloc (len
+ 1);
4377 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4382 uint
count_lines (FILE *fd
)
4386 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4392 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4394 if (nread
< 1) continue;
4398 for (i
= 0; i
< nread
; i
++)
4400 if (prev
== '\n') cnt
++;
4411 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4415 FILE *fd
= fopen (filename
, "rb");
4419 log_error ("%s: %s", filename
, strerror (errno
));
4424 #define MAX_KEY_SIZE (1024 * 1024)
4426 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4428 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4434 for (int fpos
= 0; fpos
< nread
; fpos
++)
4436 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4438 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4439 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4440 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4441 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4443 if (kpos
>= 64) kpos
= 0;
4450 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4454 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4455 if (CPU_ISSET(core
, cpu_set
)) break;
4457 thread_affinity_policy_data_t policy
= { core
};
4459 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4461 if (data
.quiet
== 0)
4463 if (rc
!= KERN_SUCCESS
)
4465 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4473 void set_cpu_affinity (char *cpu_affinity
)
4476 DWORD_PTR aff_mask
= 0;
4484 char *devices
= strdup (cpu_affinity
);
4486 char *next
= strtok (devices
, ",");
4490 uint cpu_id
= atoi (next
);
4505 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4511 aff_mask
|= 1 << (cpu_id
- 1);
4513 CPU_SET ((cpu_id
- 1), &cpuset
);
4516 } while ((next
= strtok (NULL
, ",")) != NULL
);
4522 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4523 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4525 pthread_t thread
= pthread_self ();
4526 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4530 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4532 char *element
, *end
;
4534 end
= (char *) base
+ nmemb
* size
;
4536 for (element
= (char *) base
; element
< end
; element
+= size
)
4537 if (!compar (element
, key
))
4543 int sort_by_u32 (const void *v1
, const void *v2
)
4545 const u32
*s1
= (const u32
*) v1
;
4546 const u32
*s2
= (const u32
*) v2
;
4551 int sort_by_salt (const void *v1
, const void *v2
)
4553 const salt_t
*s1
= (const salt_t
*) v1
;
4554 const salt_t
*s2
= (const salt_t
*) v2
;
4556 const int res1
= s1
->salt_len
- s2
->salt_len
;
4558 if (res1
!= 0) return (res1
);
4560 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4562 if (res2
!= 0) return (res2
);
4570 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4571 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4578 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4579 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4585 int sort_by_salt_buf (const void *v1
, const void *v2
)
4587 const pot_t
*p1
= (const pot_t
*) v1
;
4588 const pot_t
*p2
= (const pot_t
*) v2
;
4590 const hash_t
*h1
= &p1
->hash
;
4591 const hash_t
*h2
= &p2
->hash
;
4593 const salt_t
*s1
= h1
->salt
;
4594 const salt_t
*s2
= h2
->salt
;
4600 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4601 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4607 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4609 const hash_t
*h1
= (const hash_t
*) v1
;
4610 const hash_t
*h2
= (const hash_t
*) v2
;
4612 const salt_t
*s1
= h1
->salt
;
4613 const salt_t
*s2
= h2
->salt
;
4615 // testphase: this should work
4620 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4621 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4624 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4625 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4626 if (s1->salt_len > s2->salt_len) return ( 1);
4627 if (s1->salt_len < s2->salt_len) return (-1);
4629 uint n = s1->salt_len;
4633 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4634 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4641 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4643 const hash_t
*h1
= (const hash_t
*) v1
;
4644 const hash_t
*h2
= (const hash_t
*) v2
;
4646 const salt_t
*s1
= h1
->salt
;
4647 const salt_t
*s2
= h2
->salt
;
4649 // 16 - 2 (since last 2 uints contain the digest)
4654 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4655 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4661 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4663 const hash_t
*h1
= (const hash_t
*) v1
;
4664 const hash_t
*h2
= (const hash_t
*) v2
;
4666 const void *d1
= h1
->digest
;
4667 const void *d2
= h2
->digest
;
4669 return data
.sort_by_digest (d1
, d2
);
4672 int sort_by_hash (const void *v1
, const void *v2
)
4674 const hash_t
*h1
= (const hash_t
*) v1
;
4675 const hash_t
*h2
= (const hash_t
*) v2
;
4679 const salt_t
*s1
= h1
->salt
;
4680 const salt_t
*s2
= h2
->salt
;
4682 int res
= sort_by_salt (s1
, s2
);
4684 if (res
!= 0) return (res
);
4687 const void *d1
= h1
->digest
;
4688 const void *d2
= h2
->digest
;
4690 return data
.sort_by_digest (d1
, d2
);
4693 int sort_by_pot (const void *v1
, const void *v2
)
4695 const pot_t
*p1
= (const pot_t
*) v1
;
4696 const pot_t
*p2
= (const pot_t
*) v2
;
4698 const hash_t
*h1
= &p1
->hash
;
4699 const hash_t
*h2
= &p2
->hash
;
4701 return sort_by_hash (h1
, h2
);
4704 int sort_by_mtime (const void *p1
, const void *p2
)
4706 const char **f1
= (const char **) p1
;
4707 const char **f2
= (const char **) p2
;
4709 struct stat s1
; stat (*f1
, &s1
);
4710 struct stat s2
; stat (*f2
, &s2
);
4712 return s2
.st_mtime
- s1
.st_mtime
;
4715 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4717 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4718 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4720 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4723 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4725 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4726 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4728 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4731 int sort_by_stringptr (const void *p1
, const void *p2
)
4733 const char **s1
= (const char **) p1
;
4734 const char **s2
= (const char **) p2
;
4736 return strcmp (*s1
, *s2
);
4739 int sort_by_dictstat (const void *s1
, const void *s2
)
4741 dictstat_t
*d1
= (dictstat_t
*) s1
;
4742 dictstat_t
*d2
= (dictstat_t
*) s2
;
4745 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4747 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4750 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4753 int sort_by_bitmap (const void *p1
, const void *p2
)
4755 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4756 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4758 return b1
->collisions
- b2
->collisions
;
4761 int sort_by_digest_4_2 (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_4 (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_5 (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_6 (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_4_8 (const void *v1
, const void *v2
)
4827 const u32
*d1
= (const u32
*) v1
;
4828 const u32
*d2
= (const u32
*) v2
;
4834 if (d1
[n
] > d2
[n
]) return ( 1);
4835 if (d1
[n
] < d2
[n
]) return (-1);
4841 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4843 const u32
*d1
= (const u32
*) v1
;
4844 const u32
*d2
= (const u32
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4859 const u32
*d1
= (const u32
*) v1
;
4860 const u32
*d2
= (const u32
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4882 if (d1
[n
] > d2
[n
]) return ( 1);
4883 if (d1
[n
] < d2
[n
]) return (-1);
4889 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4891 const u64
*d1
= (const u64
*) v1
;
4892 const u64
*d2
= (const u64
*) v2
;
4898 if (d1
[n
] > d2
[n
]) return ( 1);
4899 if (d1
[n
] < d2
[n
]) return (-1);
4905 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4907 const u64
*d1
= (const u64
*) v1
;
4908 const u64
*d2
= (const u64
*) v2
;
4914 if (d1
[n
] > d2
[n
]) return ( 1);
4915 if (d1
[n
] < d2
[n
]) return (-1);
4921 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4923 const u64
*d1
= (const u64
*) v1
;
4924 const u64
*d2
= (const u64
*) v2
;
4930 if (d1
[n
] > d2
[n
]) return ( 1);
4931 if (d1
[n
] < d2
[n
]) return (-1);
4937 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4939 const u32
*d1
= (const u32
*) v1
;
4940 const u32
*d2
= (const u32
*) v2
;
4942 const uint dgst_pos0
= data
.dgst_pos0
;
4943 const uint dgst_pos1
= data
.dgst_pos1
;
4944 const uint dgst_pos2
= data
.dgst_pos2
;
4945 const uint dgst_pos3
= data
.dgst_pos3
;
4947 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4948 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4949 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4950 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4951 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4952 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4953 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4954 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4959 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4961 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4962 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4964 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4966 if (res1
!= 0) return (res1
);
4971 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4973 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4974 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4976 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4978 if (res1
!= 0) return (res1
);
4980 const int res2
= t1
->attack_mode
4983 if (res2
!= 0) return (res2
);
4985 const int res3
= t1
->hash_type
4988 if (res3
!= 0) return (res3
);
4993 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
)
4995 uint outfile_autohex
= data
.outfile_autohex
;
4997 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4999 FILE *debug_fp
= NULL
;
5001 if (debug_file
!= NULL
)
5003 debug_fp
= fopen (debug_file
, "ab");
5005 lock_file (debug_fp
);
5012 if (debug_fp
== NULL
)
5014 log_info ("WARNING: Could not open debug-file for writing");
5018 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5020 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5022 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5025 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5027 if (debug_mode
== 4)
5029 fputc (':', debug_fp
);
5031 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5034 fputc ('\n', debug_fp
);
5036 if (debug_file
!= NULL
) fclose (debug_fp
);
5040 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5042 int needs_hexify
= 0;
5044 if (outfile_autohex
== 1)
5046 for (uint i
= 0; i
< plain_len
; i
++)
5048 if (plain_ptr
[i
] < 0x20)
5055 if (plain_ptr
[i
] > 0x7f)
5064 if (needs_hexify
== 1)
5066 fprintf (fp
, "$HEX[");
5068 for (uint i
= 0; i
< plain_len
; i
++)
5070 fprintf (fp
, "%02x", plain_ptr
[i
]);
5077 fwrite (plain_ptr
, plain_len
, 1, fp
);
5081 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
)
5083 uint outfile_format
= data
.outfile_format
;
5085 char separator
= data
.separator
;
5087 if (outfile_format
& OUTFILE_FMT_HASH
)
5089 fprintf (out_fp
, "%s", out_buf
);
5091 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5093 fputc (separator
, out_fp
);
5096 else if (data
.username
)
5098 if (username
!= NULL
)
5100 for (uint i
= 0; i
< user_len
; i
++)
5102 fprintf (out_fp
, "%c", username
[i
]);
5105 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5107 fputc (separator
, out_fp
);
5112 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5114 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5116 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5118 fputc (separator
, out_fp
);
5122 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5124 for (uint i
= 0; i
< plain_len
; i
++)
5126 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5129 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5131 fputc (separator
, out_fp
);
5135 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5138 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5143 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5145 fprintf (out_fp
, "%llu", crackpos
);
5150 fputc ('\n', out_fp
);
5153 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
)
5157 pot_key
.hash
.salt
= hashes_buf
->salt
;
5158 pot_key
.hash
.digest
= hashes_buf
->digest
;
5160 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5166 input_buf
[input_len
] = 0;
5169 unsigned char *username
= NULL
;
5174 user_t
*user
= hashes_buf
->hash_info
->user
;
5178 username
= (unsigned char *) (user
->user_name
);
5180 user_len
= user
->user_len
;
5184 // do output the line
5185 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5189 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5190 #define LM_MASKED_PLAIN "[notfound]"
5192 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
)
5198 pot_left_key
.hash
.salt
= hash_left
->salt
;
5199 pot_left_key
.hash
.digest
= hash_left
->digest
;
5201 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5205 uint weak_hash_found
= 0;
5207 pot_t pot_right_key
;
5209 pot_right_key
.hash
.salt
= hash_right
->salt
;
5210 pot_right_key
.hash
.digest
= hash_right
->digest
;
5212 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5214 if (pot_right_ptr
== NULL
)
5216 // special case, if "weak hash"
5218 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5220 weak_hash_found
= 1;
5222 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5224 // in theory this is not needed, but we are paranoia:
5226 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5227 pot_right_ptr
->plain_len
= 0;
5231 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5233 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
5238 // at least one half was found:
5242 input_buf
[input_len
] = 0;
5246 unsigned char *username
= NULL
;
5251 user_t
*user
= hash_left
->hash_info
->user
;
5255 username
= (unsigned char *) (user
->user_name
);
5257 user_len
= user
->user_len
;
5261 // mask the part which was not found
5263 uint left_part_masked
= 0;
5264 uint right_part_masked
= 0;
5266 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5268 if (pot_left_ptr
== NULL
)
5270 left_part_masked
= 1;
5272 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5274 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5276 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5277 pot_left_ptr
->plain_len
= mask_plain_len
;
5280 if (pot_right_ptr
== NULL
)
5282 right_part_masked
= 1;
5284 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5286 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5288 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5289 pot_right_ptr
->plain_len
= mask_plain_len
;
5292 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5296 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5298 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5300 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5302 // do output the line
5304 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5306 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5308 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5309 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5312 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
)
5316 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5318 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5320 if (pot_ptr
== NULL
)
5324 input_buf
[input_len
] = 0;
5326 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5330 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
)
5336 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5338 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5342 pot_t pot_right_key
;
5344 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5346 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5348 uint weak_hash_found
= 0;
5350 if (pot_right_ptr
== NULL
)
5352 // special case, if "weak hash"
5354 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5356 weak_hash_found
= 1;
5358 // we just need that pot_right_ptr is not a NULL pointer
5360 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5364 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5366 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5371 // ... at least one part was not cracked
5375 input_buf
[input_len
] = 0;
5377 // only show the hash part which is still not cracked
5379 uint user_len
= input_len
- 32;
5381 char *hash_output
= (char *) mymalloc (33);
5383 memcpy (hash_output
, input_buf
, input_len
);
5385 if (pot_left_ptr
!= NULL
)
5387 // only show right part (because left part was already found)
5389 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5391 hash_output
[user_len
+ 16] = 0;
5394 if (pot_right_ptr
!= NULL
)
5396 // only show left part (because right part was already found)
5398 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5400 hash_output
[user_len
+ 16] = 0;
5403 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5405 myfree (hash_output
);
5407 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5410 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5412 uint opencl_platforms_filter
= 0;
5414 if (opencl_platforms
)
5416 char *platforms
= strdup (opencl_platforms
);
5418 char *next
= strtok (platforms
, ",");
5422 int platform
= atoi (next
);
5424 if (platform
< 1 || platform
> 32)
5426 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5431 opencl_platforms_filter
|= 1 << (platform
- 1);
5433 } while ((next
= strtok (NULL
, ",")) != NULL
);
5439 opencl_platforms_filter
= -1;
5442 return opencl_platforms_filter
;
5445 u32
setup_devices_filter (char *opencl_devices
)
5447 u32 devices_filter
= 0;
5451 char *devices
= strdup (opencl_devices
);
5453 char *next
= strtok (devices
, ",");
5457 int device_id
= atoi (next
);
5459 if (device_id
< 1 || device_id
> 32)
5461 log_error ("ERROR: invalid device_id %u specified", device_id
);
5466 devices_filter
|= 1 << (device_id
- 1);
5468 } while ((next
= strtok (NULL
, ",")) != NULL
);
5474 devices_filter
= -1;
5477 return devices_filter
;
5480 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5482 cl_device_type device_types_filter
= 0;
5484 if (opencl_device_types
)
5486 char *device_types
= strdup (opencl_device_types
);
5488 char *next
= strtok (device_types
, ",");
5492 int device_type
= atoi (next
);
5494 if (device_type
< 1 || device_type
> 3)
5496 log_error ("ERROR: invalid device_type %u specified", device_type
);
5501 device_types_filter
|= 1 << device_type
;
5503 } while ((next
= strtok (NULL
, ",")) != NULL
);
5505 free (device_types
);
5509 // Do not use CPU by default, this often reduces GPU performance because
5510 // the CPU is too busy to handle GPU synchronization
5512 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5515 return device_types_filter
;
5518 u32
get_random_num (const u32 min
, const u32 max
)
5520 if (min
== max
) return (min
);
5522 return ((rand () % (max
- min
)) + min
);
5525 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5527 u32 quotient
= dividend
/ divisor
;
5529 if (dividend
% divisor
) quotient
++;
5534 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5536 u64 quotient
= dividend
/ divisor
;
5538 if (dividend
% divisor
) quotient
++;
5543 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5545 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5546 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5548 if (tm
->tm_year
- 70)
5550 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5551 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5553 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5555 else if (tm
->tm_yday
)
5557 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5558 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5560 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5562 else if (tm
->tm_hour
)
5564 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5565 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5567 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5569 else if (tm
->tm_min
)
5571 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5572 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5574 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5578 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5580 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5584 void format_speed_display (float val
, char *buf
, size_t len
)
5595 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5606 /* generate output */
5610 snprintf (buf
, len
- 1, "%.0f ", val
);
5614 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5618 void lowercase (u8
*buf
, int len
)
5620 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5623 void uppercase (u8
*buf
, int len
)
5625 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5628 int fgetl (FILE *fp
, char *line_buf
)
5634 const int c
= fgetc (fp
);
5636 if (c
== EOF
) break;
5638 line_buf
[line_len
] = (char) c
;
5642 if (line_len
== HCBUFSIZ
) line_len
--;
5644 if (c
== '\n') break;
5647 if (line_len
== 0) return 0;
5649 if (line_buf
[line_len
- 1] == '\n')
5653 line_buf
[line_len
] = 0;
5656 if (line_len
== 0) return 0;
5658 if (line_buf
[line_len
- 1] == '\r')
5662 line_buf
[line_len
] = 0;
5668 int in_superchop (char *buf
)
5670 int len
= strlen (buf
);
5674 if (buf
[len
- 1] == '\n')
5681 if (buf
[len
- 1] == '\r')
5696 char **scan_directory (const char *path
)
5698 char *tmp_path
= mystrdup (path
);
5700 size_t tmp_path_len
= strlen (tmp_path
);
5702 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5704 tmp_path
[tmp_path_len
- 1] = 0;
5706 tmp_path_len
= strlen (tmp_path
);
5709 char **files
= NULL
;
5715 if ((d
= opendir (tmp_path
)) != NULL
)
5721 memset (&e
, 0, sizeof (e
));
5722 struct dirent
*de
= NULL
;
5724 if (readdir_r (d
, &e
, &de
) != 0)
5726 log_error ("ERROR: readdir_r() failed");
5731 if (de
== NULL
) break;
5735 while ((de
= readdir (d
)) != NULL
)
5738 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5740 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5742 char *path_file
= (char *) mymalloc (path_size
+ 1);
5744 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5746 path_file
[path_size
] = 0;
5750 if ((d_test
= opendir (path_file
)) != NULL
)
5758 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5762 files
[num_files
- 1] = path_file
;
5768 else if (errno
== ENOTDIR
)
5770 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5774 files
[num_files
- 1] = mystrdup (path
);
5777 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5781 files
[num_files
- 1] = NULL
;
5788 int count_dictionaries (char **dictionary_files
)
5790 if (dictionary_files
== NULL
) return 0;
5794 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5802 char *stroptitype (const uint opti_type
)
5806 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5807 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5808 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5809 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5810 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5811 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5812 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5813 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5814 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5815 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5816 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5817 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5818 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5819 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5820 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5821 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5822 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5823 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5824 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5830 char *strparser (const uint parser_status
)
5832 switch (parser_status
)
5834 case PARSER_OK
: return ((char *) PA_000
); break;
5835 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5836 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5837 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5838 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5839 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5840 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5841 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5842 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5843 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5844 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5845 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5846 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5847 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5848 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5849 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5850 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5853 return ((char *) PA_255
);
5856 char *strhashtype (const uint hash_mode
)
5860 case 0: return ((char *) HT_00000
); break;
5861 case 10: return ((char *) HT_00010
); break;
5862 case 11: return ((char *) HT_00011
); break;
5863 case 12: return ((char *) HT_00012
); break;
5864 case 20: return ((char *) HT_00020
); break;
5865 case 21: return ((char *) HT_00021
); break;
5866 case 22: return ((char *) HT_00022
); break;
5867 case 23: return ((char *) HT_00023
); break;
5868 case 30: return ((char *) HT_00030
); break;
5869 case 40: return ((char *) HT_00040
); break;
5870 case 50: return ((char *) HT_00050
); break;
5871 case 60: return ((char *) HT_00060
); break;
5872 case 100: return ((char *) HT_00100
); break;
5873 case 101: return ((char *) HT_00101
); break;
5874 case 110: return ((char *) HT_00110
); break;
5875 case 111: return ((char *) HT_00111
); break;
5876 case 112: return ((char *) HT_00112
); break;
5877 case 120: return ((char *) HT_00120
); break;
5878 case 121: return ((char *) HT_00121
); break;
5879 case 122: return ((char *) HT_00122
); break;
5880 case 124: return ((char *) HT_00124
); break;
5881 case 125: return ((char *) HT_00125
); break;
5882 case 130: return ((char *) HT_00130
); break;
5883 case 131: return ((char *) HT_00131
); break;
5884 case 132: return ((char *) HT_00132
); break;
5885 case 133: return ((char *) HT_00133
); break;
5886 case 140: return ((char *) HT_00140
); break;
5887 case 141: return ((char *) HT_00141
); break;
5888 case 150: return ((char *) HT_00150
); break;
5889 case 160: return ((char *) HT_00160
); break;
5890 case 190: return ((char *) HT_00190
); break;
5891 case 200: return ((char *) HT_00200
); break;
5892 case 300: return ((char *) HT_00300
); break;
5893 case 400: return ((char *) HT_00400
); break;
5894 case 500: return ((char *) HT_00500
); break;
5895 case 501: return ((char *) HT_00501
); break;
5896 case 900: return ((char *) HT_00900
); break;
5897 case 910: return ((char *) HT_00910
); break;
5898 case 1000: return ((char *) HT_01000
); break;
5899 case 1100: return ((char *) HT_01100
); break;
5900 case 1400: return ((char *) HT_01400
); break;
5901 case 1410: return ((char *) HT_01410
); break;
5902 case 1420: return ((char *) HT_01420
); break;
5903 case 1421: return ((char *) HT_01421
); break;
5904 case 1430: return ((char *) HT_01430
); break;
5905 case 1440: return ((char *) HT_01440
); break;
5906 case 1441: return ((char *) HT_01441
); break;
5907 case 1450: return ((char *) HT_01450
); break;
5908 case 1460: return ((char *) HT_01460
); break;
5909 case 1500: return ((char *) HT_01500
); break;
5910 case 1600: return ((char *) HT_01600
); break;
5911 case 1700: return ((char *) HT_01700
); break;
5912 case 1710: return ((char *) HT_01710
); break;
5913 case 1711: return ((char *) HT_01711
); break;
5914 case 1720: return ((char *) HT_01720
); break;
5915 case 1722: return ((char *) HT_01722
); break;
5916 case 1730: return ((char *) HT_01730
); break;
5917 case 1731: return ((char *) HT_01731
); break;
5918 case 1740: return ((char *) HT_01740
); break;
5919 case 1750: return ((char *) HT_01750
); break;
5920 case 1760: return ((char *) HT_01760
); break;
5921 case 1800: return ((char *) HT_01800
); break;
5922 case 2100: return ((char *) HT_02100
); break;
5923 case 2400: return ((char *) HT_02400
); break;
5924 case 2410: return ((char *) HT_02410
); break;
5925 case 2500: return ((char *) HT_02500
); break;
5926 case 2600: return ((char *) HT_02600
); break;
5927 case 2611: return ((char *) HT_02611
); break;
5928 case 2612: return ((char *) HT_02612
); break;
5929 case 2711: return ((char *) HT_02711
); break;
5930 case 2811: return ((char *) HT_02811
); break;
5931 case 3000: return ((char *) HT_03000
); break;
5932 case 3100: return ((char *) HT_03100
); break;
5933 case 3200: return ((char *) HT_03200
); break;
5934 case 3710: return ((char *) HT_03710
); break;
5935 case 3711: return ((char *) HT_03711
); break;
5936 case 3800: return ((char *) HT_03800
); break;
5937 case 4300: return ((char *) HT_04300
); break;
5938 case 4400: return ((char *) HT_04400
); break;
5939 case 4500: return ((char *) HT_04500
); break;
5940 case 4700: return ((char *) HT_04700
); break;
5941 case 4800: return ((char *) HT_04800
); break;
5942 case 4900: return ((char *) HT_04900
); break;
5943 case 5000: return ((char *) HT_05000
); break;
5944 case 5100: return ((char *) HT_05100
); break;
5945 case 5200: return ((char *) HT_05200
); break;
5946 case 5300: return ((char *) HT_05300
); break;
5947 case 5400: return ((char *) HT_05400
); break;
5948 case 5500: return ((char *) HT_05500
); break;
5949 case 5600: return ((char *) HT_05600
); break;
5950 case 5700: return ((char *) HT_05700
); break;
5951 case 5800: return ((char *) HT_05800
); break;
5952 case 6000: return ((char *) HT_06000
); break;
5953 case 6100: return ((char *) HT_06100
); break;
5954 case 6211: return ((char *) HT_06211
); break;
5955 case 6212: return ((char *) HT_06212
); break;
5956 case 6213: return ((char *) HT_06213
); break;
5957 case 6221: return ((char *) HT_06221
); break;
5958 case 6222: return ((char *) HT_06222
); break;
5959 case 6223: return ((char *) HT_06223
); break;
5960 case 6231: return ((char *) HT_06231
); break;
5961 case 6232: return ((char *) HT_06232
); break;
5962 case 6233: return ((char *) HT_06233
); break;
5963 case 6241: return ((char *) HT_06241
); break;
5964 case 6242: return ((char *) HT_06242
); break;
5965 case 6243: return ((char *) HT_06243
); break;
5966 case 6300: return ((char *) HT_06300
); break;
5967 case 6400: return ((char *) HT_06400
); break;
5968 case 6500: return ((char *) HT_06500
); break;
5969 case 6600: return ((char *) HT_06600
); break;
5970 case 6700: return ((char *) HT_06700
); break;
5971 case 6800: return ((char *) HT_06800
); break;
5972 case 6900: return ((char *) HT_06900
); break;
5973 case 7100: return ((char *) HT_07100
); break;
5974 case 7200: return ((char *) HT_07200
); break;
5975 case 7300: return ((char *) HT_07300
); break;
5976 case 7400: return ((char *) HT_07400
); break;
5977 case 7500: return ((char *) HT_07500
); break;
5978 case 7600: return ((char *) HT_07600
); break;
5979 case 7700: return ((char *) HT_07700
); break;
5980 case 7800: return ((char *) HT_07800
); break;
5981 case 7900: return ((char *) HT_07900
); break;
5982 case 8000: return ((char *) HT_08000
); break;
5983 case 8100: return ((char *) HT_08100
); break;
5984 case 8200: return ((char *) HT_08200
); break;
5985 case 8300: return ((char *) HT_08300
); break;
5986 case 8400: return ((char *) HT_08400
); break;
5987 case 8500: return ((char *) HT_08500
); break;
5988 case 8600: return ((char *) HT_08600
); break;
5989 case 8700: return ((char *) HT_08700
); break;
5990 case 8800: return ((char *) HT_08800
); break;
5991 case 8900: return ((char *) HT_08900
); break;
5992 case 9000: return ((char *) HT_09000
); break;
5993 case 9100: return ((char *) HT_09100
); break;
5994 case 9200: return ((char *) HT_09200
); break;
5995 case 9300: return ((char *) HT_09300
); break;
5996 case 9400: return ((char *) HT_09400
); break;
5997 case 9500: return ((char *) HT_09500
); break;
5998 case 9600: return ((char *) HT_09600
); break;
5999 case 9700: return ((char *) HT_09700
); break;
6000 case 9710: return ((char *) HT_09710
); break;
6001 case 9720: return ((char *) HT_09720
); break;
6002 case 9800: return ((char *) HT_09800
); break;
6003 case 9810: return ((char *) HT_09810
); break;
6004 case 9820: return ((char *) HT_09820
); break;
6005 case 9900: return ((char *) HT_09900
); break;
6006 case 10000: return ((char *) HT_10000
); break;
6007 case 10100: return ((char *) HT_10100
); break;
6008 case 10200: return ((char *) HT_10200
); break;
6009 case 10300: return ((char *) HT_10300
); break;
6010 case 10400: return ((char *) HT_10400
); break;
6011 case 10410: return ((char *) HT_10410
); break;
6012 case 10420: return ((char *) HT_10420
); break;
6013 case 10500: return ((char *) HT_10500
); break;
6014 case 10600: return ((char *) HT_10600
); break;
6015 case 10700: return ((char *) HT_10700
); break;
6016 case 10800: return ((char *) HT_10800
); break;
6017 case 10900: return ((char *) HT_10900
); break;
6018 case 11000: return ((char *) HT_11000
); break;
6019 case 11100: return ((char *) HT_11100
); break;
6020 case 11200: return ((char *) HT_11200
); break;
6021 case 11300: return ((char *) HT_11300
); break;
6022 case 11400: return ((char *) HT_11400
); break;
6023 case 11500: return ((char *) HT_11500
); break;
6024 case 11600: return ((char *) HT_11600
); break;
6025 case 11700: return ((char *) HT_11700
); break;
6026 case 11800: return ((char *) HT_11800
); break;
6027 case 11900: return ((char *) HT_11900
); break;
6028 case 12000: return ((char *) HT_12000
); break;
6029 case 12100: return ((char *) HT_12100
); break;
6030 case 12200: return ((char *) HT_12200
); break;
6031 case 12300: return ((char *) HT_12300
); break;
6032 case 12400: return ((char *) HT_12400
); break;
6033 case 12500: return ((char *) HT_12500
); break;
6034 case 12600: return ((char *) HT_12600
); break;
6035 case 12700: return ((char *) HT_12700
); break;
6036 case 12800: return ((char *) HT_12800
); break;
6037 case 12900: return ((char *) HT_12900
); break;
6038 case 13000: return ((char *) HT_13000
); break;
6039 case 13100: return ((char *) HT_13100
); break;
6040 case 13200: return ((char *) HT_13200
); break;
6041 case 13300: return ((char *) HT_13300
); break;
6042 case 13400: return ((char *) HT_13400
); break;
6043 case 13500: return ((char *) HT_13500
); break;
6044 case 13600: return ((char *) HT_13600
); break;
6045 case 13711: return ((char *) HT_13711
); break;
6046 case 13712: return ((char *) HT_13712
); break;
6047 case 13713: return ((char *) HT_13713
); break;
6048 case 13721: return ((char *) HT_13721
); break;
6049 case 13722: return ((char *) HT_13722
); break;
6050 case 13723: return ((char *) HT_13723
); break;
6051 case 13731: return ((char *) HT_13731
); break;
6052 case 13732: return ((char *) HT_13732
); break;
6053 case 13733: return ((char *) HT_13733
); break;
6054 case 13741: return ((char *) HT_13741
); break;
6055 case 13742: return ((char *) HT_13742
); break;
6056 case 13743: return ((char *) HT_13743
); break;
6057 case 13751: return ((char *) HT_13751
); break;
6058 case 13752: return ((char *) HT_13752
); break;
6059 case 13753: return ((char *) HT_13753
); break;
6060 case 13761: return ((char *) HT_13761
); break;
6061 case 13762: return ((char *) HT_13762
); break;
6062 case 13763: return ((char *) HT_13763
); break;
6065 return ((char *) "Unknown");
6068 char *strstatus (const uint devices_status
)
6070 switch (devices_status
)
6072 case STATUS_INIT
: return ((char *) ST_0000
); break;
6073 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6074 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6075 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6076 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6077 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6078 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6079 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6080 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6081 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6082 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6085 return ((char *) "Unknown");
6088 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6090 uint hash_type
= data
.hash_type
;
6091 uint hash_mode
= data
.hash_mode
;
6092 uint salt_type
= data
.salt_type
;
6093 uint opts_type
= data
.opts_type
;
6094 uint opti_type
= data
.opti_type
;
6095 uint dgst_size
= data
.dgst_size
;
6097 char *hashfile
= data
.hashfile
;
6101 uint digest_buf
[64] = { 0 };
6103 u64
*digest_buf64
= (u64
*) digest_buf
;
6105 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6107 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6109 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6115 case HASH_TYPE_DESCRYPT
:
6116 FP (digest_buf
[1], digest_buf
[0], tt
);
6119 case HASH_TYPE_DESRACF
:
6120 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6121 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6123 FP (digest_buf
[1], digest_buf
[0], tt
);
6127 FP (digest_buf
[1], digest_buf
[0], tt
);
6130 case HASH_TYPE_NETNTLM
:
6131 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6132 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6133 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6134 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6136 FP (digest_buf
[1], digest_buf
[0], tt
);
6137 FP (digest_buf
[3], digest_buf
[2], tt
);
6140 case HASH_TYPE_BSDICRYPT
:
6141 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6142 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6144 FP (digest_buf
[1], digest_buf
[0], tt
);
6149 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6154 digest_buf
[0] += MD4M_A
;
6155 digest_buf
[1] += MD4M_B
;
6156 digest_buf
[2] += MD4M_C
;
6157 digest_buf
[3] += MD4M_D
;
6161 digest_buf
[0] += MD5M_A
;
6162 digest_buf
[1] += MD5M_B
;
6163 digest_buf
[2] += MD5M_C
;
6164 digest_buf
[3] += MD5M_D
;
6167 case HASH_TYPE_SHA1
:
6168 digest_buf
[0] += SHA1M_A
;
6169 digest_buf
[1] += SHA1M_B
;
6170 digest_buf
[2] += SHA1M_C
;
6171 digest_buf
[3] += SHA1M_D
;
6172 digest_buf
[4] += SHA1M_E
;
6175 case HASH_TYPE_SHA256
:
6176 digest_buf
[0] += SHA256M_A
;
6177 digest_buf
[1] += SHA256M_B
;
6178 digest_buf
[2] += SHA256M_C
;
6179 digest_buf
[3] += SHA256M_D
;
6180 digest_buf
[4] += SHA256M_E
;
6181 digest_buf
[5] += SHA256M_F
;
6182 digest_buf
[6] += SHA256M_G
;
6183 digest_buf
[7] += SHA256M_H
;
6186 case HASH_TYPE_SHA384
:
6187 digest_buf64
[0] += SHA384M_A
;
6188 digest_buf64
[1] += SHA384M_B
;
6189 digest_buf64
[2] += SHA384M_C
;
6190 digest_buf64
[3] += SHA384M_D
;
6191 digest_buf64
[4] += SHA384M_E
;
6192 digest_buf64
[5] += SHA384M_F
;
6193 digest_buf64
[6] += 0;
6194 digest_buf64
[7] += 0;
6197 case HASH_TYPE_SHA512
:
6198 digest_buf64
[0] += SHA512M_A
;
6199 digest_buf64
[1] += SHA512M_B
;
6200 digest_buf64
[2] += SHA512M_C
;
6201 digest_buf64
[3] += SHA512M_D
;
6202 digest_buf64
[4] += SHA512M_E
;
6203 digest_buf64
[5] += SHA512M_F
;
6204 digest_buf64
[6] += SHA512M_G
;
6205 digest_buf64
[7] += SHA512M_H
;
6210 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6212 if (dgst_size
== DGST_SIZE_4_2
)
6214 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6216 else if (dgst_size
== DGST_SIZE_4_4
)
6218 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6220 else if (dgst_size
== DGST_SIZE_4_5
)
6222 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6224 else if (dgst_size
== DGST_SIZE_4_6
)
6226 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6228 else if (dgst_size
== DGST_SIZE_4_8
)
6230 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6232 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6234 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6236 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6238 else if (hash_type
== HASH_TYPE_SHA384
)
6240 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6242 else if (hash_type
== HASH_TYPE_SHA512
)
6244 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6246 else if (hash_type
== HASH_TYPE_GOST
)
6248 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6251 else if (dgst_size
== DGST_SIZE_4_64
)
6253 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6255 else if (dgst_size
== DGST_SIZE_8_25
)
6257 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6261 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6262 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6263 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6269 memset (&salt
, 0, sizeof (salt_t
));
6271 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6273 char *ptr
= (char *) salt
.salt_buf
;
6275 uint len
= salt
.salt_len
;
6277 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6283 case HASH_TYPE_NETNTLM
:
6285 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6286 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6288 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6294 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6296 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6304 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6306 uint max
= salt
.salt_len
/ 4;
6310 for (uint i
= 0; i
< max
; i
++)
6312 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6316 if (opts_type
& OPTS_TYPE_ST_HEX
)
6318 char tmp
[64] = { 0 };
6320 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6322 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6327 memcpy (ptr
, tmp
, len
);
6330 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6332 memset (ptr
+ len
, 0, memset_size
);
6334 salt
.salt_len
= len
;
6338 // some modes require special encoding
6341 uint out_buf_plain
[256] = { 0 };
6342 uint out_buf_salt
[256] = { 0 };
6344 char tmp_buf
[1024] = { 0 };
6346 char *ptr_plain
= (char *) out_buf_plain
;
6347 char *ptr_salt
= (char *) out_buf_salt
;
6349 if (hash_mode
== 22)
6351 char username
[30] = { 0 };
6353 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6355 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6357 u16
*ptr
= (u16
*) digest_buf
;
6359 tmp_buf
[ 0] = sig
[0];
6360 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6361 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6362 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6363 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6364 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6365 tmp_buf
[ 6] = sig
[1];
6366 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6367 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6368 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6369 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6370 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6371 tmp_buf
[12] = sig
[2];
6372 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6373 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6374 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6375 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6376 tmp_buf
[17] = sig
[3];
6377 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6378 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6379 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6380 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6381 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6382 tmp_buf
[23] = sig
[4];
6383 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6384 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6385 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6386 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6387 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6388 tmp_buf
[29] = sig
[5];
6390 snprintf (out_buf
, len
-1, "%s:%s",
6394 else if (hash_mode
== 23)
6396 // do not show the skyper part in output
6398 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6400 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6402 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6409 else if (hash_mode
== 101)
6411 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6413 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6414 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6415 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6416 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6417 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6419 memcpy (tmp_buf
, digest_buf
, 20);
6421 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6423 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6425 else if (hash_mode
== 111)
6427 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6429 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6430 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6431 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6432 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6433 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6435 memcpy (tmp_buf
, digest_buf
, 20);
6436 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6438 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6440 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6442 else if ((hash_mode
== 122) || (hash_mode
== 125))
6444 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6445 (char *) salt
.salt_buf
,
6452 else if (hash_mode
== 124)
6454 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6455 (char *) salt
.salt_buf
,
6462 else if (hash_mode
== 131)
6464 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6465 (char *) salt
.salt_buf
,
6473 else if (hash_mode
== 132)
6475 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6476 (char *) salt
.salt_buf
,
6483 else if (hash_mode
== 133)
6485 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6487 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6488 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6489 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6490 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6491 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6493 memcpy (tmp_buf
, digest_buf
, 20);
6495 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6497 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6499 else if (hash_mode
== 141)
6501 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6503 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6505 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6507 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6509 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6510 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6511 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6512 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6513 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6515 memcpy (tmp_buf
, digest_buf
, 20);
6517 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6521 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6523 else if (hash_mode
== 400)
6525 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6527 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6528 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6529 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6530 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6532 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6534 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6536 else if (hash_mode
== 500)
6538 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6540 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6541 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6542 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6543 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6545 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6547 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6549 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6553 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6556 else if (hash_mode
== 501)
6558 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6560 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6561 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6563 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6565 else if (hash_mode
== 1421)
6567 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6569 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6585 else if (hash_mode
== 1441)
6587 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6589 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6591 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6593 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6595 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6596 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6597 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6598 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6599 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6600 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6601 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6602 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6604 memcpy (tmp_buf
, digest_buf
, 32);
6606 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6610 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6612 else if (hash_mode
== 1500)
6614 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6615 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6616 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6617 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6618 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6620 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6622 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6624 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6625 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6627 memcpy (tmp_buf
, digest_buf
, 8);
6629 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6631 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6635 else if (hash_mode
== 1600)
6637 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6639 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6640 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6641 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6642 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6644 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6646 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6648 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6652 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6655 else if (hash_mode
== 1711)
6657 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6659 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6660 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6661 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6662 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6663 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6664 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6665 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6666 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6668 memcpy (tmp_buf
, digest_buf
, 64);
6669 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6671 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6673 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6675 else if (hash_mode
== 1722)
6677 uint
*ptr
= digest_buf
;
6679 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6680 (unsigned char *) salt
.salt_buf
,
6690 else if (hash_mode
== 1731)
6692 uint
*ptr
= digest_buf
;
6694 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6695 (unsigned char *) salt
.salt_buf
,
6705 else if (hash_mode
== 1800)
6709 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6710 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6711 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6712 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6713 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6714 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6715 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6716 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6718 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6720 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6722 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6726 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6729 else if (hash_mode
== 2100)
6733 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6735 salt
.salt_iter
+ 1);
6737 uint signature_len
= strlen (out_buf
);
6739 pos
+= signature_len
;
6740 len
-= signature_len
;
6742 char *salt_ptr
= (char *) salt
.salt_buf
;
6744 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6746 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6747 byte_swap_32 (digest_buf
[0]),
6748 byte_swap_32 (digest_buf
[1]),
6749 byte_swap_32 (digest_buf
[2]),
6750 byte_swap_32 (digest_buf
[3]));
6752 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6754 memcpy (tmp_buf
, digest_buf
, 16);
6756 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6758 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6759 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6760 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6761 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6763 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6764 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6765 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6766 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6768 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6769 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6770 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6771 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6773 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6774 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6775 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6776 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6778 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6779 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6780 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6781 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6785 else if (hash_mode
== 2500)
6787 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6789 wpa_t
*wpa
= &wpas
[salt_pos
];
6791 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6792 (char *) salt
.salt_buf
,
6806 else if (hash_mode
== 4400)
6808 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6809 byte_swap_32 (digest_buf
[0]),
6810 byte_swap_32 (digest_buf
[1]),
6811 byte_swap_32 (digest_buf
[2]),
6812 byte_swap_32 (digest_buf
[3]));
6814 else if (hash_mode
== 4700)
6816 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6817 byte_swap_32 (digest_buf
[0]),
6818 byte_swap_32 (digest_buf
[1]),
6819 byte_swap_32 (digest_buf
[2]),
6820 byte_swap_32 (digest_buf
[3]),
6821 byte_swap_32 (digest_buf
[4]));
6823 else if (hash_mode
== 4800)
6825 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6827 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6832 byte_swap_32 (salt
.salt_buf
[0]),
6833 byte_swap_32 (salt
.salt_buf
[1]),
6834 byte_swap_32 (salt
.salt_buf
[2]),
6835 byte_swap_32 (salt
.salt_buf
[3]),
6838 else if (hash_mode
== 4900)
6840 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6841 byte_swap_32 (digest_buf
[0]),
6842 byte_swap_32 (digest_buf
[1]),
6843 byte_swap_32 (digest_buf
[2]),
6844 byte_swap_32 (digest_buf
[3]),
6845 byte_swap_32 (digest_buf
[4]));
6847 else if (hash_mode
== 5100)
6849 snprintf (out_buf
, len
-1, "%08x%08x",
6853 else if (hash_mode
== 5200)
6855 snprintf (out_buf
, len
-1, "%s", hashfile
);
6857 else if (hash_mode
== 5300)
6859 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6861 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6863 int buf_len
= len
-1;
6867 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6869 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6871 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6873 snprintf (out_buf
, buf_len
, ":");
6879 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6887 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6889 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6891 if ((i
== 0) || (i
== 5))
6893 snprintf (out_buf
, buf_len
, ":");
6899 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6907 for (uint i
= 0; i
< 4; i
++)
6911 snprintf (out_buf
, buf_len
, ":");
6917 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6923 else if (hash_mode
== 5400)
6925 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6927 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6929 int buf_len
= len
-1;
6933 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6935 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6937 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6939 snprintf (out_buf
, buf_len
, ":");
6945 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6953 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6955 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6957 if ((i
== 0) || (i
== 5))
6959 snprintf (out_buf
, buf_len
, ":");
6965 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6973 for (uint i
= 0; i
< 5; i
++)
6977 snprintf (out_buf
, buf_len
, ":");
6983 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6989 else if (hash_mode
== 5500)
6991 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6993 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6995 char user_buf
[64] = { 0 };
6996 char domain_buf
[64] = { 0 };
6997 char srvchall_buf
[1024] = { 0 };
6998 char clichall_buf
[1024] = { 0 };
7000 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7002 char *ptr
= (char *) netntlm
->userdomain_buf
;
7004 user_buf
[i
] = ptr
[j
];
7007 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7009 char *ptr
= (char *) netntlm
->userdomain_buf
;
7011 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7014 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7016 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7018 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7021 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7023 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7025 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7028 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7036 byte_swap_32 (salt
.salt_buf_pc
[0]),
7037 byte_swap_32 (salt
.salt_buf_pc
[1]),
7040 else if (hash_mode
== 5600)
7042 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7044 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7046 char user_buf
[64] = { 0 };
7047 char domain_buf
[64] = { 0 };
7048 char srvchall_buf
[1024] = { 0 };
7049 char clichall_buf
[1024] = { 0 };
7051 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7053 char *ptr
= (char *) netntlm
->userdomain_buf
;
7055 user_buf
[i
] = ptr
[j
];
7058 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7060 char *ptr
= (char *) netntlm
->userdomain_buf
;
7062 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7065 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7067 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7069 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7072 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7074 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7076 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7079 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7089 else if (hash_mode
== 5700)
7091 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7093 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7094 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7095 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7096 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7097 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7098 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7099 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7100 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7102 memcpy (tmp_buf
, digest_buf
, 32);
7104 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7108 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7110 else if (hash_mode
== 5800)
7112 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7113 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7114 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7115 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7116 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7118 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7125 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7127 snprintf (out_buf
, len
-1, "%s", hashfile
);
7129 else if (hash_mode
== 6300)
7131 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7133 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7134 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7135 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7136 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7138 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7140 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7142 else if (hash_mode
== 6400)
7144 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7146 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7148 else if (hash_mode
== 6500)
7150 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7152 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7154 else if (hash_mode
== 6600)
7156 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7158 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7160 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7161 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7163 uint buf_len
= len
- 1;
7165 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7168 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7170 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7175 else if (hash_mode
== 6700)
7177 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7179 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7181 else if (hash_mode
== 6800)
7183 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7185 else if (hash_mode
== 7100)
7187 uint
*ptr
= digest_buf
;
7189 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7191 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7193 uint esalt
[8] = { 0 };
7195 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7196 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7197 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7198 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7199 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7200 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7201 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7202 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7204 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",
7205 SIGNATURE_SHA512OSX
,
7207 esalt
[ 0], esalt
[ 1],
7208 esalt
[ 2], esalt
[ 3],
7209 esalt
[ 4], esalt
[ 5],
7210 esalt
[ 6], esalt
[ 7],
7218 ptr
[15], ptr
[14]);
7220 else if (hash_mode
== 7200)
7222 uint
*ptr
= digest_buf
;
7224 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7226 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7230 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7232 len_used
= strlen (out_buf
);
7234 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7236 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7238 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7241 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",
7249 ptr
[15], ptr
[14]);
7251 else if (hash_mode
== 7300)
7253 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7255 rakp_t
*rakp
= &rakps
[salt_pos
];
7257 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7259 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7262 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7269 else if (hash_mode
== 7400)
7271 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7273 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7274 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7275 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7276 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7277 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7278 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7279 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7280 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7282 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7284 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7286 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7290 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7293 else if (hash_mode
== 7500)
7295 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7297 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7299 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7300 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7302 char data
[128] = { 0 };
7304 char *ptr_data
= data
;
7306 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7308 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7311 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7313 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7318 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7320 (char *) krb5pa
->user
,
7321 (char *) krb5pa
->realm
,
7322 (char *) krb5pa
->salt
,
7325 else if (hash_mode
== 7700)
7327 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7328 (char *) salt
.salt_buf
,
7332 else if (hash_mode
== 7800)
7334 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7335 (char *) salt
.salt_buf
,
7342 else if (hash_mode
== 7900)
7344 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7348 char *tmp
= (char *) salt
.salt_buf_pc
;
7350 ptr_plain
[42] = tmp
[0];
7356 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7358 else if (hash_mode
== 8000)
7360 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7361 (unsigned char *) salt
.salt_buf
,
7371 else if (hash_mode
== 8100)
7373 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7374 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7376 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7377 (unsigned char *) salt
.salt_buf
,
7384 else if (hash_mode
== 8200)
7386 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7388 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7390 char data_buf
[4096] = { 0 };
7392 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7394 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7397 data_buf
[cloudkey
->data_len
* 2] = 0;
7399 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7400 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7401 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7402 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7403 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7404 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7405 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7406 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7408 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7409 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7410 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7411 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7413 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7429 else if (hash_mode
== 8300)
7431 char digest_buf_c
[34] = { 0 };
7433 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7434 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7435 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7436 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7437 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7439 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7441 digest_buf_c
[32] = 0;
7445 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7447 char domain_buf_c
[33] = { 0 };
7449 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7451 for (uint i
= 0; i
< salt_pc_len
; i
++)
7453 const char next
= domain_buf_c
[i
];
7455 domain_buf_c
[i
] = '.';
7460 domain_buf_c
[salt_pc_len
] = 0;
7464 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7466 else if (hash_mode
== 8500)
7468 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7470 else if (hash_mode
== 2612)
7472 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7474 (char *) salt
.salt_buf
,
7480 else if (hash_mode
== 3711)
7482 char *salt_ptr
= (char *) salt
.salt_buf
;
7484 salt_ptr
[salt
.salt_len
- 1] = 0;
7486 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7487 SIGNATURE_MEDIAWIKI_B
,
7494 else if (hash_mode
== 8800)
7496 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7498 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7500 char tmp
[3073] = { 0 };
7502 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7504 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7509 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7510 SIGNATURE_ANDROIDFDE
,
7511 byte_swap_32 (salt
.salt_buf
[0]),
7512 byte_swap_32 (salt
.salt_buf
[1]),
7513 byte_swap_32 (salt
.salt_buf
[2]),
7514 byte_swap_32 (salt
.salt_buf
[3]),
7515 byte_swap_32 (digest_buf
[0]),
7516 byte_swap_32 (digest_buf
[1]),
7517 byte_swap_32 (digest_buf
[2]),
7518 byte_swap_32 (digest_buf
[3]),
7521 else if (hash_mode
== 8900)
7523 uint N
= salt
.scrypt_N
;
7524 uint r
= salt
.scrypt_r
;
7525 uint p
= salt
.scrypt_p
;
7527 char base64_salt
[32] = { 0 };
7529 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7531 memset (tmp_buf
, 0, 46);
7533 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7534 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7535 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7536 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7537 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7538 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7539 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7540 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7541 digest_buf
[8] = 0; // needed for base64_encode ()
7543 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7545 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7553 else if (hash_mode
== 9000)
7555 snprintf (out_buf
, len
-1, "%s", hashfile
);
7557 else if (hash_mode
== 9200)
7561 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7563 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7565 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7569 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7570 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7571 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7572 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7573 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7574 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7575 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7576 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7577 digest_buf
[8] = 0; // needed for base64_encode ()
7579 char tmp_buf
[64] = { 0 };
7581 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7582 tmp_buf
[43] = 0; // cut it here
7586 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7588 else if (hash_mode
== 9300)
7590 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7591 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7592 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7593 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7594 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7595 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7596 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7597 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7598 digest_buf
[8] = 0; // needed for base64_encode ()
7600 char tmp_buf
[64] = { 0 };
7602 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7603 tmp_buf
[43] = 0; // cut it here
7605 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7607 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7609 else if (hash_mode
== 9400)
7611 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7613 office2007_t
*office2007
= &office2007s
[salt_pos
];
7615 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7616 SIGNATURE_OFFICE2007
,
7619 office2007
->keySize
,
7625 office2007
->encryptedVerifier
[0],
7626 office2007
->encryptedVerifier
[1],
7627 office2007
->encryptedVerifier
[2],
7628 office2007
->encryptedVerifier
[3],
7629 office2007
->encryptedVerifierHash
[0],
7630 office2007
->encryptedVerifierHash
[1],
7631 office2007
->encryptedVerifierHash
[2],
7632 office2007
->encryptedVerifierHash
[3],
7633 office2007
->encryptedVerifierHash
[4]);
7635 else if (hash_mode
== 9500)
7637 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7639 office2010_t
*office2010
= &office2010s
[salt_pos
];
7641 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,
7647 office2010
->encryptedVerifier
[0],
7648 office2010
->encryptedVerifier
[1],
7649 office2010
->encryptedVerifier
[2],
7650 office2010
->encryptedVerifier
[3],
7651 office2010
->encryptedVerifierHash
[0],
7652 office2010
->encryptedVerifierHash
[1],
7653 office2010
->encryptedVerifierHash
[2],
7654 office2010
->encryptedVerifierHash
[3],
7655 office2010
->encryptedVerifierHash
[4],
7656 office2010
->encryptedVerifierHash
[5],
7657 office2010
->encryptedVerifierHash
[6],
7658 office2010
->encryptedVerifierHash
[7]);
7660 else if (hash_mode
== 9600)
7662 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7664 office2013_t
*office2013
= &office2013s
[salt_pos
];
7666 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,
7672 office2013
->encryptedVerifier
[0],
7673 office2013
->encryptedVerifier
[1],
7674 office2013
->encryptedVerifier
[2],
7675 office2013
->encryptedVerifier
[3],
7676 office2013
->encryptedVerifierHash
[0],
7677 office2013
->encryptedVerifierHash
[1],
7678 office2013
->encryptedVerifierHash
[2],
7679 office2013
->encryptedVerifierHash
[3],
7680 office2013
->encryptedVerifierHash
[4],
7681 office2013
->encryptedVerifierHash
[5],
7682 office2013
->encryptedVerifierHash
[6],
7683 office2013
->encryptedVerifierHash
[7]);
7685 else if (hash_mode
== 9700)
7687 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7689 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7691 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7692 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7693 byte_swap_32 (salt
.salt_buf
[0]),
7694 byte_swap_32 (salt
.salt_buf
[1]),
7695 byte_swap_32 (salt
.salt_buf
[2]),
7696 byte_swap_32 (salt
.salt_buf
[3]),
7697 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7698 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7699 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7700 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7701 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7702 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7703 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7704 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7706 else if (hash_mode
== 9710)
7708 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7710 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7712 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7713 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7714 byte_swap_32 (salt
.salt_buf
[0]),
7715 byte_swap_32 (salt
.salt_buf
[1]),
7716 byte_swap_32 (salt
.salt_buf
[2]),
7717 byte_swap_32 (salt
.salt_buf
[3]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7721 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7722 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7723 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7724 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7725 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7727 else if (hash_mode
== 9720)
7729 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7731 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7733 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7735 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7736 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7737 byte_swap_32 (salt
.salt_buf
[0]),
7738 byte_swap_32 (salt
.salt_buf
[1]),
7739 byte_swap_32 (salt
.salt_buf
[2]),
7740 byte_swap_32 (salt
.salt_buf
[3]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7742 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7743 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7744 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7745 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7746 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7747 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7748 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7755 else if (hash_mode
== 9800)
7757 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7759 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7761 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7762 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7767 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7768 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7769 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7770 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7771 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7772 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7773 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7774 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7775 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7777 else if (hash_mode
== 9810)
7779 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7781 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7783 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7784 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7789 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7792 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7793 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7794 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7795 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7796 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7797 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7799 else if (hash_mode
== 9820)
7801 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7803 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7805 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7807 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7808 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7813 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7814 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7815 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7816 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7817 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7818 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7819 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7820 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7821 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7828 else if (hash_mode
== 10000)
7832 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7834 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7836 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7840 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7841 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7842 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7843 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7844 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7845 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7846 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7847 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7848 digest_buf
[8] = 0; // needed for base64_encode ()
7850 char tmp_buf
[64] = { 0 };
7852 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7856 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7858 else if (hash_mode
== 10100)
7860 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7865 byte_swap_32 (salt
.salt_buf
[0]),
7866 byte_swap_32 (salt
.salt_buf
[1]),
7867 byte_swap_32 (salt
.salt_buf
[2]),
7868 byte_swap_32 (salt
.salt_buf
[3]));
7870 else if (hash_mode
== 10200)
7872 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7874 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7878 char challenge
[100] = { 0 };
7880 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7884 char tmp_buf
[100] = { 0 };
7886 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7887 (char *) cram_md5
->user
,
7893 char response
[100] = { 0 };
7895 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7897 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7899 else if (hash_mode
== 10300)
7901 char tmp_buf
[100] = { 0 };
7903 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7904 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7906 uint tmp_len
= 20 + salt
.salt_len
;
7910 char base64_encoded
[100] = { 0 };
7912 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7914 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7916 else if (hash_mode
== 10400)
7918 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7920 pdf_t
*pdf
= &pdfs
[salt_pos
];
7922 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",
7930 byte_swap_32 (pdf
->id_buf
[0]),
7931 byte_swap_32 (pdf
->id_buf
[1]),
7932 byte_swap_32 (pdf
->id_buf
[2]),
7933 byte_swap_32 (pdf
->id_buf
[3]),
7935 byte_swap_32 (pdf
->u_buf
[0]),
7936 byte_swap_32 (pdf
->u_buf
[1]),
7937 byte_swap_32 (pdf
->u_buf
[2]),
7938 byte_swap_32 (pdf
->u_buf
[3]),
7939 byte_swap_32 (pdf
->u_buf
[4]),
7940 byte_swap_32 (pdf
->u_buf
[5]),
7941 byte_swap_32 (pdf
->u_buf
[6]),
7942 byte_swap_32 (pdf
->u_buf
[7]),
7944 byte_swap_32 (pdf
->o_buf
[0]),
7945 byte_swap_32 (pdf
->o_buf
[1]),
7946 byte_swap_32 (pdf
->o_buf
[2]),
7947 byte_swap_32 (pdf
->o_buf
[3]),
7948 byte_swap_32 (pdf
->o_buf
[4]),
7949 byte_swap_32 (pdf
->o_buf
[5]),
7950 byte_swap_32 (pdf
->o_buf
[6]),
7951 byte_swap_32 (pdf
->o_buf
[7])
7954 else if (hash_mode
== 10410)
7956 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7958 pdf_t
*pdf
= &pdfs
[salt_pos
];
7960 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",
7968 byte_swap_32 (pdf
->id_buf
[0]),
7969 byte_swap_32 (pdf
->id_buf
[1]),
7970 byte_swap_32 (pdf
->id_buf
[2]),
7971 byte_swap_32 (pdf
->id_buf
[3]),
7973 byte_swap_32 (pdf
->u_buf
[0]),
7974 byte_swap_32 (pdf
->u_buf
[1]),
7975 byte_swap_32 (pdf
->u_buf
[2]),
7976 byte_swap_32 (pdf
->u_buf
[3]),
7977 byte_swap_32 (pdf
->u_buf
[4]),
7978 byte_swap_32 (pdf
->u_buf
[5]),
7979 byte_swap_32 (pdf
->u_buf
[6]),
7980 byte_swap_32 (pdf
->u_buf
[7]),
7982 byte_swap_32 (pdf
->o_buf
[0]),
7983 byte_swap_32 (pdf
->o_buf
[1]),
7984 byte_swap_32 (pdf
->o_buf
[2]),
7985 byte_swap_32 (pdf
->o_buf
[3]),
7986 byte_swap_32 (pdf
->o_buf
[4]),
7987 byte_swap_32 (pdf
->o_buf
[5]),
7988 byte_swap_32 (pdf
->o_buf
[6]),
7989 byte_swap_32 (pdf
->o_buf
[7])
7992 else if (hash_mode
== 10420)
7994 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7996 pdf_t
*pdf
= &pdfs
[salt_pos
];
7998 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8000 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",
8008 byte_swap_32 (pdf
->id_buf
[0]),
8009 byte_swap_32 (pdf
->id_buf
[1]),
8010 byte_swap_32 (pdf
->id_buf
[2]),
8011 byte_swap_32 (pdf
->id_buf
[3]),
8013 byte_swap_32 (pdf
->u_buf
[0]),
8014 byte_swap_32 (pdf
->u_buf
[1]),
8015 byte_swap_32 (pdf
->u_buf
[2]),
8016 byte_swap_32 (pdf
->u_buf
[3]),
8017 byte_swap_32 (pdf
->u_buf
[4]),
8018 byte_swap_32 (pdf
->u_buf
[5]),
8019 byte_swap_32 (pdf
->u_buf
[6]),
8020 byte_swap_32 (pdf
->u_buf
[7]),
8022 byte_swap_32 (pdf
->o_buf
[0]),
8023 byte_swap_32 (pdf
->o_buf
[1]),
8024 byte_swap_32 (pdf
->o_buf
[2]),
8025 byte_swap_32 (pdf
->o_buf
[3]),
8026 byte_swap_32 (pdf
->o_buf
[4]),
8027 byte_swap_32 (pdf
->o_buf
[5]),
8028 byte_swap_32 (pdf
->o_buf
[6]),
8029 byte_swap_32 (pdf
->o_buf
[7]),
8037 else if (hash_mode
== 10500)
8039 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8041 pdf_t
*pdf
= &pdfs
[salt_pos
];
8043 if (pdf
->id_len
== 32)
8045 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",
8053 byte_swap_32 (pdf
->id_buf
[0]),
8054 byte_swap_32 (pdf
->id_buf
[1]),
8055 byte_swap_32 (pdf
->id_buf
[2]),
8056 byte_swap_32 (pdf
->id_buf
[3]),
8057 byte_swap_32 (pdf
->id_buf
[4]),
8058 byte_swap_32 (pdf
->id_buf
[5]),
8059 byte_swap_32 (pdf
->id_buf
[6]),
8060 byte_swap_32 (pdf
->id_buf
[7]),
8062 byte_swap_32 (pdf
->u_buf
[0]),
8063 byte_swap_32 (pdf
->u_buf
[1]),
8064 byte_swap_32 (pdf
->u_buf
[2]),
8065 byte_swap_32 (pdf
->u_buf
[3]),
8066 byte_swap_32 (pdf
->u_buf
[4]),
8067 byte_swap_32 (pdf
->u_buf
[5]),
8068 byte_swap_32 (pdf
->u_buf
[6]),
8069 byte_swap_32 (pdf
->u_buf
[7]),
8071 byte_swap_32 (pdf
->o_buf
[0]),
8072 byte_swap_32 (pdf
->o_buf
[1]),
8073 byte_swap_32 (pdf
->o_buf
[2]),
8074 byte_swap_32 (pdf
->o_buf
[3]),
8075 byte_swap_32 (pdf
->o_buf
[4]),
8076 byte_swap_32 (pdf
->o_buf
[5]),
8077 byte_swap_32 (pdf
->o_buf
[6]),
8078 byte_swap_32 (pdf
->o_buf
[7])
8083 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",
8091 byte_swap_32 (pdf
->id_buf
[0]),
8092 byte_swap_32 (pdf
->id_buf
[1]),
8093 byte_swap_32 (pdf
->id_buf
[2]),
8094 byte_swap_32 (pdf
->id_buf
[3]),
8096 byte_swap_32 (pdf
->u_buf
[0]),
8097 byte_swap_32 (pdf
->u_buf
[1]),
8098 byte_swap_32 (pdf
->u_buf
[2]),
8099 byte_swap_32 (pdf
->u_buf
[3]),
8100 byte_swap_32 (pdf
->u_buf
[4]),
8101 byte_swap_32 (pdf
->u_buf
[5]),
8102 byte_swap_32 (pdf
->u_buf
[6]),
8103 byte_swap_32 (pdf
->u_buf
[7]),
8105 byte_swap_32 (pdf
->o_buf
[0]),
8106 byte_swap_32 (pdf
->o_buf
[1]),
8107 byte_swap_32 (pdf
->o_buf
[2]),
8108 byte_swap_32 (pdf
->o_buf
[3]),
8109 byte_swap_32 (pdf
->o_buf
[4]),
8110 byte_swap_32 (pdf
->o_buf
[5]),
8111 byte_swap_32 (pdf
->o_buf
[6]),
8112 byte_swap_32 (pdf
->o_buf
[7])
8116 else if (hash_mode
== 10600)
8118 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8120 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8121 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8123 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8125 else if (hash_mode
== 10700)
8127 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8129 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8130 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8132 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8134 else if (hash_mode
== 10900)
8136 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8138 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8139 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8141 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8143 else if (hash_mode
== 11100)
8145 u32 salt_challenge
= salt
.salt_buf
[0];
8147 salt_challenge
= byte_swap_32 (salt_challenge
);
8149 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8151 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8152 SIGNATURE_POSTGRESQL_AUTH
,
8160 else if (hash_mode
== 11200)
8162 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8163 SIGNATURE_MYSQL_AUTH
,
8164 (unsigned char *) salt
.salt_buf
,
8171 else if (hash_mode
== 11300)
8173 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8175 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8177 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8178 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8179 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8181 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8182 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8183 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8185 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8187 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8189 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8192 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8194 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8196 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8199 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8201 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8203 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8206 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8207 SIGNATURE_BITCOIN_WALLET
,
8211 (unsigned char *) salt
.salt_buf
,
8219 free (cry_master_buf
);
8221 free (public_key_buf
);
8223 else if (hash_mode
== 11400)
8225 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8227 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8228 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8230 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8232 else if (hash_mode
== 11600)
8234 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8236 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8238 const uint data_len
= seven_zip
->data_len
;
8240 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8242 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8244 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8246 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8249 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8250 SIGNATURE_SEVEN_ZIP
,
8254 (char *) seven_zip
->salt_buf
,
8256 seven_zip
->iv_buf
[0],
8257 seven_zip
->iv_buf
[1],
8258 seven_zip
->iv_buf
[2],
8259 seven_zip
->iv_buf
[3],
8261 seven_zip
->data_len
,
8262 seven_zip
->unpack_size
,
8267 else if (hash_mode
== 11700)
8269 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8279 else if (hash_mode
== 11800)
8281 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8299 else if (hash_mode
== 11900)
8301 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8303 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8304 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8306 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8308 else if (hash_mode
== 12000)
8310 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8312 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8313 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8315 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8317 else if (hash_mode
== 12100)
8319 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8321 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8322 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8324 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8326 else if (hash_mode
== 12200)
8328 uint
*ptr_digest
= digest_buf
;
8329 uint
*ptr_salt
= salt
.salt_buf
;
8331 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8338 else if (hash_mode
== 12300)
8340 uint
*ptr_digest
= digest_buf
;
8341 uint
*ptr_salt
= salt
.salt_buf
;
8343 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",
8344 ptr_digest
[ 0], ptr_digest
[ 1],
8345 ptr_digest
[ 2], ptr_digest
[ 3],
8346 ptr_digest
[ 4], ptr_digest
[ 5],
8347 ptr_digest
[ 6], ptr_digest
[ 7],
8348 ptr_digest
[ 8], ptr_digest
[ 9],
8349 ptr_digest
[10], ptr_digest
[11],
8350 ptr_digest
[12], ptr_digest
[13],
8351 ptr_digest
[14], ptr_digest
[15],
8357 else if (hash_mode
== 12400)
8359 // encode iteration count
8361 char salt_iter
[5] = { 0 };
8363 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8364 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8365 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8366 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8371 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8372 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8373 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8374 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8379 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8381 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8382 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8384 memcpy (tmp_buf
, digest_buf
, 8);
8386 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8390 // fill the resulting buffer
8392 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8394 else if (hash_mode
== 12500)
8396 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8398 byte_swap_32 (salt
.salt_buf
[0]),
8399 byte_swap_32 (salt
.salt_buf
[1]),
8405 else if (hash_mode
== 12600)
8407 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8408 digest_buf
[0] + salt
.salt_buf_pc
[0],
8409 digest_buf
[1] + salt
.salt_buf_pc
[1],
8410 digest_buf
[2] + salt
.salt_buf_pc
[2],
8411 digest_buf
[3] + salt
.salt_buf_pc
[3],
8412 digest_buf
[4] + salt
.salt_buf_pc
[4],
8413 digest_buf
[5] + salt
.salt_buf_pc
[5],
8414 digest_buf
[6] + salt
.salt_buf_pc
[6],
8415 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8417 else if (hash_mode
== 12700)
8419 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8421 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8422 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8424 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8426 else if (hash_mode
== 12800)
8428 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8430 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",
8443 byte_swap_32 (digest_buf
[0]),
8444 byte_swap_32 (digest_buf
[1]),
8445 byte_swap_32 (digest_buf
[2]),
8446 byte_swap_32 (digest_buf
[3]),
8447 byte_swap_32 (digest_buf
[4]),
8448 byte_swap_32 (digest_buf
[5]),
8449 byte_swap_32 (digest_buf
[6]),
8450 byte_swap_32 (digest_buf
[7])
8453 else if (hash_mode
== 12900)
8455 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",
8464 byte_swap_32 (digest_buf
[0]),
8465 byte_swap_32 (digest_buf
[1]),
8466 byte_swap_32 (digest_buf
[2]),
8467 byte_swap_32 (digest_buf
[3]),
8468 byte_swap_32 (digest_buf
[4]),
8469 byte_swap_32 (digest_buf
[5]),
8470 byte_swap_32 (digest_buf
[6]),
8471 byte_swap_32 (digest_buf
[7]),
8478 else if (hash_mode
== 13000)
8480 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8482 rar5_t
*rar5
= &rar5s
[salt_pos
];
8484 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8494 byte_swap_32 (digest_buf
[0]),
8495 byte_swap_32 (digest_buf
[1])
8498 else if (hash_mode
== 13100)
8500 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8502 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8504 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8505 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8507 char data
[2560 * 4 * 2] = { 0 };
8509 char *ptr_data
= data
;
8511 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8512 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8517 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8518 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8520 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8522 (char *) krb5tgs
->account_info
,
8526 else if (hash_mode
== 13200)
8528 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8542 else if (hash_mode
== 13300)
8544 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8545 SIGNATURE_AXCRYPT_SHA1
,
8551 else if (hash_mode
== 13400)
8553 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8555 keepass_t
*keepass
= &keepasss
[salt_pos
];
8557 u32 version
= (u32
) keepass
->version
;
8558 u32 rounds
= salt
.salt_iter
;
8559 u32 algorithm
= (u32
) keepass
->algorithm
;
8560 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8562 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8563 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8564 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8565 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8566 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8568 /* specific to version 1 */
8572 /* specific to version 2 */
8573 u32 expected_bytes_len
;
8574 u32
*ptr_expected_bytes
;
8576 u32 final_random_seed_len
;
8577 u32 transf_random_seed_len
;
8579 u32 contents_hash_len
;
8581 transf_random_seed_len
= 8;
8583 contents_hash_len
= 8;
8584 final_random_seed_len
= 8;
8587 final_random_seed_len
= 4;
8589 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8595 char *ptr_data
= out_buf
;
8597 ptr_data
+= strlen(out_buf
);
8602 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8603 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8608 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8609 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8614 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8615 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8622 contents_len
= (u32
) keepass
->contents_len
;
8623 ptr_contents
= (u32
*) keepass
->contents
;
8625 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8626 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8638 char ptr_contents_len
[10] = { 0 };
8640 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8642 sprintf (ptr_data
, "%d", contents_len
);
8644 ptr_data
+= strlen(ptr_contents_len
);
8649 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8650 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8652 else if (version
== 2)
8654 expected_bytes_len
= 8;
8655 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8657 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8658 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8663 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8664 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8678 sprintf (ptr_data
, "%d", keyfile_len
);
8685 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8686 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8689 else if (hash_mode
== 13500)
8691 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8693 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8695 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8697 char pstoken_tmp
[1024 + 1] = { 0 };
8699 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8701 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8703 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8706 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8714 else if (hash_mode
== 13600)
8716 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8718 zip2_t
*zip2
= &zip2s
[salt_pos
];
8720 const u32 salt_len
= zip2
->salt_len
;
8722 char salt_tmp
[32 + 1] = { 0 };
8724 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8726 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8728 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8731 const u32 data_len
= zip2
->data_len
;
8733 char data_tmp
[8192 + 1] = { 0 };
8735 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8737 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8739 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8742 const u32 auth_len
= zip2
->auth_len
;
8744 char auth_tmp
[20 + 1] = { 0 };
8746 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8748 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8750 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8753 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8754 SIGNATURE_ZIP2_START
,
8760 zip2
->compress_length
,
8763 SIGNATURE_ZIP2_STOP
);
8765 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8767 snprintf (out_buf
, len
-1, "%s", hashfile
);
8771 if (hash_type
== HASH_TYPE_MD4
)
8773 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8779 else if (hash_type
== HASH_TYPE_MD5
)
8781 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8787 else if (hash_type
== HASH_TYPE_SHA1
)
8789 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8796 else if (hash_type
== HASH_TYPE_SHA256
)
8798 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8808 else if (hash_type
== HASH_TYPE_SHA384
)
8810 uint
*ptr
= digest_buf
;
8812 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8820 else if (hash_type
== HASH_TYPE_SHA512
)
8822 uint
*ptr
= digest_buf
;
8824 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8834 else if (hash_type
== HASH_TYPE_LM
)
8836 snprintf (out_buf
, len
-1, "%08x%08x",
8840 else if (hash_type
== HASH_TYPE_ORACLEH
)
8842 snprintf (out_buf
, len
-1, "%08X%08X",
8846 else if (hash_type
== HASH_TYPE_BCRYPT
)
8848 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8849 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8851 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8853 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8855 else if (hash_type
== HASH_TYPE_KECCAK
)
8857 uint
*ptr
= digest_buf
;
8859 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",
8887 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8889 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8891 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8898 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8900 digest_buf
[ 0] = digest_buf
[ 0];
8901 digest_buf
[ 1] = digest_buf
[ 1];
8902 digest_buf
[ 2] = digest_buf
[ 2];
8903 digest_buf
[ 3] = digest_buf
[ 3];
8904 digest_buf
[ 4] = digest_buf
[ 4];
8905 digest_buf
[ 5] = digest_buf
[ 5];
8906 digest_buf
[ 6] = digest_buf
[ 6];
8907 digest_buf
[ 7] = digest_buf
[ 7];
8908 digest_buf
[ 8] = digest_buf
[ 8];
8909 digest_buf
[ 9] = digest_buf
[ 9];
8910 digest_buf
[10] = digest_buf
[10];
8911 digest_buf
[11] = digest_buf
[11];
8912 digest_buf
[12] = digest_buf
[12];
8913 digest_buf
[13] = digest_buf
[13];
8914 digest_buf
[14] = digest_buf
[14];
8915 digest_buf
[15] = digest_buf
[15];
8917 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8935 else if (hash_type
== HASH_TYPE_GOST
)
8937 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8947 else if (hash_type
== HASH_TYPE_MYSQL
)
8949 snprintf (out_buf
, len
-1, "%08x%08x",
8953 else if (hash_type
== HASH_TYPE_LOTUS5
)
8955 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8961 else if (hash_type
== HASH_TYPE_LOTUS6
)
8963 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8964 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8965 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8966 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8968 char buf
[16] = { 0 };
8970 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8971 memcpy (buf
+ 5, digest_buf
, 9);
8975 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8977 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8980 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8982 else if (hash_type
== HASH_TYPE_LOTUS8
)
8984 char buf
[52] = { 0 };
8988 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8994 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8998 buf
[26] = salt
.salt_buf_pc
[0];
8999 buf
[27] = salt
.salt_buf_pc
[1];
9003 memcpy (buf
+ 28, digest_buf
, 8);
9005 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9009 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9011 else if (hash_type
== HASH_TYPE_CRC32
)
9013 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9017 if (salt_type
== SALT_TYPE_INTERN
)
9019 size_t pos
= strlen (out_buf
);
9021 out_buf
[pos
] = data
.separator
;
9023 char *ptr
= (char *) salt
.salt_buf
;
9025 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9027 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9031 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9033 memset (hccap
, 0, sizeof (hccap_t
));
9035 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9037 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9039 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9040 wpa_t
*wpa
= &wpas
[salt_pos
];
9042 hccap
->keyver
= wpa
->keyver
;
9044 hccap
->eapol_size
= wpa
->eapol_size
;
9046 if (wpa
->keyver
!= 1)
9048 uint eapol_tmp
[64] = { 0 };
9050 for (uint i
= 0; i
< 64; i
++)
9052 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9055 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9059 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9062 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9063 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9064 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9065 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9067 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9069 uint dgst_size
= data
.dgst_size
;
9071 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9073 if (wpa
->keyver
!= 1)
9075 uint digest_tmp
[4] = { 0 };
9077 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9078 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9079 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9080 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9082 memcpy (hccap
->keymic
, digest_tmp
, 16);
9086 memcpy (hccap
->keymic
, digest_ptr
, 16);
9090 void SuspendThreads ()
9092 if (data
.devices_status
== STATUS_RUNNING
)
9094 hc_timer_set (&data
.timer_paused
);
9096 data
.devices_status
= STATUS_PAUSED
;
9098 log_info ("Paused");
9102 void ResumeThreads ()
9104 if (data
.devices_status
== STATUS_PAUSED
)
9108 hc_timer_get (data
.timer_paused
, ms_paused
);
9110 data
.ms_paused
+= ms_paused
;
9112 data
.devices_status
= STATUS_RUNNING
;
9114 log_info ("Resumed");
9120 if (data
.devices_status
!= STATUS_RUNNING
) return;
9122 data
.devices_status
= STATUS_BYPASS
;
9124 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9127 void stop_at_checkpoint ()
9129 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9131 if (data
.devices_status
!= STATUS_RUNNING
) return;
9134 // this feature only makes sense if --restore-disable was not specified
9136 if (data
.restore_disable
== 1)
9138 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9143 // check if monitoring of Restore Point updates should be enabled or disabled
9145 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9147 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9149 // save the current restore point value
9151 data
.checkpoint_cur_words
= get_lowest_words_done ();
9153 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9157 data
.devices_status
= STATUS_RUNNING
;
9159 // reset the global value for checkpoint checks
9161 data
.checkpoint_cur_words
= 0;
9163 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9169 if (data
.devices_status
== STATUS_INIT
) return;
9170 if (data
.devices_status
== STATUS_STARTING
) return;
9172 data
.devices_status
= STATUS_ABORTED
;
9177 if (data
.devices_status
== STATUS_INIT
) return;
9178 if (data
.devices_status
== STATUS_STARTING
) return;
9180 data
.devices_status
= STATUS_QUIT
;
9183 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9185 FILE *fp
= fopen (kernel_file
, "rb");
9191 memset (&st
, 0, sizeof (st
));
9193 stat (kernel_file
, &st
);
9195 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9197 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9199 if (num_read
!= (size_t) st
.st_size
)
9201 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9208 buf
[st
.st_size
] = 0;
9210 for (int i
= 0; i
< num_devices
; i
++)
9212 kernel_lengths
[i
] = (size_t) st
.st_size
;
9214 kernel_sources
[i
] = buf
;
9219 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9227 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9229 if (binary_size
> 0)
9231 FILE *fp
= fopen (dst
, "wb");
9234 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9245 restore_data_t
*init_restore (int argc
, char **argv
)
9247 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9249 if (data
.restore_disable
== 0)
9251 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9255 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9259 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9268 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9270 int pidbin_len
= -1;
9273 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9275 FILE *fd
= fopen (pidbin
, "rb");
9279 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9281 pidbin
[pidbin_len
] = 0;
9285 char *argv0_r
= strrchr (argv
[0], '/');
9287 char *pidbin_r
= strrchr (pidbin
, '/');
9289 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9291 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9293 if (strcmp (argv0_r
, pidbin_r
) == 0)
9295 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9302 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9304 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9306 int pidbin2_len
= -1;
9308 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9309 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9311 pidbin
[pidbin_len
] = 0;
9312 pidbin2
[pidbin2_len
] = 0;
9316 if (strcmp (pidbin
, pidbin2
) == 0)
9318 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9331 if (rd
->version_bin
< RESTORE_MIN
)
9333 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9340 memset (rd
, 0, sizeof (restore_data_t
));
9342 rd
->version_bin
= VERSION_BIN
;
9345 rd
->pid
= getpid ();
9347 rd
->pid
= GetCurrentProcessId ();
9350 if (getcwd (rd
->cwd
, 255) == NULL
)
9363 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9365 FILE *fp
= fopen (eff_restore_file
, "rb");
9369 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9374 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9376 log_error ("ERROR: cannot read %s", eff_restore_file
);
9381 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9383 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9385 for (uint i
= 0; i
< rd
->argc
; i
++)
9387 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9389 log_error ("ERROR: cannot read %s", eff_restore_file
);
9394 size_t len
= strlen (buf
);
9396 if (len
) buf
[len
- 1] = 0;
9398 rd
->argv
[i
] = mystrdup (buf
);
9405 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9407 if (chdir (rd
->cwd
))
9409 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9410 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9411 " https://github.com/philsmd/analyze_hc_restore\n"
9412 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9418 u64
get_lowest_words_done ()
9422 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9424 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9426 if (device_param
->skipped
) continue;
9428 const u64 words_done
= device_param
->words_done
;
9430 if (words_done
< words_cur
) words_cur
= words_done
;
9433 // It's possible that a device's workload isn't finished right after a restore-case.
9434 // In that case, this function would return 0 and overwrite the real restore point
9435 // There's also data.words_cur which is set to rd->words_cur but it changes while
9436 // the attack is running therefore we should stick to rd->words_cur.
9437 // Note that -s influences rd->words_cur we should keep a close look on that.
9439 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9444 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9446 u64 words_cur
= get_lowest_words_done ();
9448 rd
->words_cur
= words_cur
;
9450 FILE *fp
= fopen (new_restore_file
, "wb");
9454 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9459 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9461 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9466 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9468 for (uint i
= 0; i
< rd
->argc
; i
++)
9470 fprintf (fp
, "%s", rd
->argv
[i
]);
9476 fsync (fileno (fp
));
9481 void cycle_restore ()
9483 const char *eff_restore_file
= data
.eff_restore_file
;
9484 const char *new_restore_file
= data
.new_restore_file
;
9486 restore_data_t
*rd
= data
.rd
;
9488 write_restore (new_restore_file
, rd
);
9492 memset (&st
, 0, sizeof(st
));
9494 if (stat (eff_restore_file
, &st
) == 0)
9496 if (unlink (eff_restore_file
))
9498 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9502 if (rename (new_restore_file
, eff_restore_file
))
9504 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9508 void check_checkpoint ()
9510 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9512 u64 words_cur
= get_lowest_words_done ();
9514 if (words_cur
!= data
.checkpoint_cur_words
)
9524 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9528 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9530 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9532 myfree (alias
->device_name
);
9533 myfree (alias
->alias_name
);
9536 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9538 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9540 myfree (entry
->device_name
);
9543 myfree (tuning_db
->alias_buf
);
9544 myfree (tuning_db
->entry_buf
);
9549 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9551 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9553 int num_lines
= count_lines (fp
);
9555 // a bit over-allocated
9557 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9558 tuning_db
->alias_cnt
= 0;
9560 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9561 tuning_db
->entry_cnt
= 0;
9566 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9568 FILE *fp
= fopen (tuning_db_file
, "rb");
9572 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9577 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9583 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9587 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9589 if (line_buf
== NULL
) break;
9593 const int line_len
= in_superchop (line_buf
);
9595 if (line_len
== 0) continue;
9597 if (line_buf
[0] == '#') continue;
9601 char *token_ptr
[7] = { NULL
};
9605 char *next
= strtok (line_buf
, "\t ");
9607 token_ptr
[token_cnt
] = next
;
9611 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9613 token_ptr
[token_cnt
] = next
;
9620 char *device_name
= token_ptr
[0];
9621 char *alias_name
= token_ptr
[1];
9623 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9625 alias
->device_name
= mystrdup (device_name
);
9626 alias
->alias_name
= mystrdup (alias_name
);
9628 tuning_db
->alias_cnt
++;
9630 else if (token_cnt
== 6)
9632 if ((token_ptr
[1][0] != '0') &&
9633 (token_ptr
[1][0] != '1') &&
9634 (token_ptr
[1][0] != '3') &&
9635 (token_ptr
[1][0] != '*'))
9637 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9642 if ((token_ptr
[3][0] != '1') &&
9643 (token_ptr
[3][0] != '2') &&
9644 (token_ptr
[3][0] != '4') &&
9645 (token_ptr
[3][0] != '8') &&
9646 (token_ptr
[3][0] != 'N'))
9648 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9653 char *device_name
= token_ptr
[0];
9655 int attack_mode
= -1;
9657 int vector_width
= -1;
9658 int kernel_accel
= -1;
9659 int kernel_loops
= -1;
9661 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9662 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9663 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9665 if (token_ptr
[4][0] != 'A')
9667 kernel_accel
= atoi (token_ptr
[4]);
9669 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9671 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9681 if (token_ptr
[5][0] != 'A')
9683 kernel_loops
= atoi (token_ptr
[5]);
9685 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9687 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9697 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9699 entry
->device_name
= mystrdup (device_name
);
9700 entry
->attack_mode
= attack_mode
;
9701 entry
->hash_type
= hash_type
;
9702 entry
->vector_width
= vector_width
;
9703 entry
->kernel_accel
= kernel_accel
;
9704 entry
->kernel_loops
= kernel_loops
;
9706 tuning_db
->entry_cnt
++;
9710 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9720 // todo: print loaded 'cnt' message
9722 // sort the database
9724 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9725 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9730 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9732 static tuning_db_entry_t s
;
9734 // first we need to convert all spaces in the device_name to underscore
9736 char *device_name_nospace
= strdup (device_param
->device_name
);
9738 int device_name_length
= strlen (device_name_nospace
);
9742 for (i
= 0; i
< device_name_length
; i
++)
9744 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9747 // find out if there's an alias configured
9749 tuning_db_alias_t a
;
9751 a
.device_name
= device_name_nospace
;
9753 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
);
9755 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9757 // attack-mode 6 and 7 are attack-mode 1 basically
9759 if (attack_mode
== 6) attack_mode
= 1;
9760 if (attack_mode
== 7) attack_mode
= 1;
9762 // bsearch is not ideal but fast enough
9764 s
.device_name
= device_name_nospace
;
9765 s
.attack_mode
= attack_mode
;
9766 s
.hash_type
= hash_type
;
9768 tuning_db_entry_t
*entry
= NULL
;
9770 // this will produce all 2^3 combinations required
9772 for (i
= 0; i
< 8; i
++)
9774 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9775 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9776 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9778 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9780 if (entry
!= NULL
) break;
9782 // in non-wildcard mode do some additional checks:
9786 // in case we have an alias-name
9788 if (alias_name
!= NULL
)
9790 s
.device_name
= alias_name
;
9792 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9794 if (entry
!= NULL
) break;
9797 // or by device type
9799 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9801 s
.device_name
= "DEVICE_TYPE_CPU";
9803 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9805 s
.device_name
= "DEVICE_TYPE_GPU";
9807 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9809 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9812 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9814 if (entry
!= NULL
) break;
9818 // free converted device_name
9820 myfree (device_name_nospace
);
9829 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9831 u8 tmp
[256] = { 0 };
9833 if (salt_len
> sizeof (tmp
))
9838 memcpy (tmp
, in
, salt_len
);
9840 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9842 if ((salt_len
% 2) == 0)
9844 u32 new_salt_len
= salt_len
/ 2;
9846 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9851 tmp
[i
] = hex_convert (p1
) << 0;
9852 tmp
[i
] |= hex_convert (p0
) << 4;
9855 salt_len
= new_salt_len
;
9862 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9864 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9867 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9869 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9873 u32
*tmp_uint
= (u32
*) tmp
;
9875 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9876 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9877 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9878 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9879 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9880 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9881 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9882 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9883 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9884 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9886 salt_len
= salt_len
* 2;
9894 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9896 lowercase (tmp
, salt_len
);
9899 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9901 uppercase (tmp
, salt_len
);
9906 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9911 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9916 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9918 u32
*tmp_uint
= (uint
*) tmp
;
9924 for (u32 i
= 0; i
< max
; i
++)
9926 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9929 // Important: we may need to increase the length of memcpy since
9930 // we don't want to "loose" some swapped bytes (could happen if
9931 // they do not perfectly fit in the 4-byte blocks)
9932 // Memcpy does always copy the bytes in the BE order, but since
9933 // we swapped them, some important bytes could be in positions
9934 // we normally skip with the original len
9936 if (len
% 4) len
+= 4 - (len
% 4);
9939 memcpy (out
, tmp
, len
);
9944 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9946 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9948 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9950 u32
*digest
= (u32
*) hash_buf
->digest
;
9952 salt_t
*salt
= hash_buf
->salt
;
9954 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9956 char *iter_pos
= input_buf
+ 4;
9958 salt
->salt_iter
= 1 << atoi (iter_pos
);
9960 char *salt_pos
= strchr (iter_pos
, '$');
9962 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9968 salt
->salt_len
= salt_len
;
9970 u8 tmp_buf
[100] = { 0 };
9972 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9974 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9976 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9978 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9979 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9980 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9981 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9983 char *hash_pos
= salt_pos
+ 22;
9985 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9987 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9989 memcpy (digest
, tmp_buf
, 24);
9991 digest
[0] = byte_swap_32 (digest
[0]);
9992 digest
[1] = byte_swap_32 (digest
[1]);
9993 digest
[2] = byte_swap_32 (digest
[2]);
9994 digest
[3] = byte_swap_32 (digest
[3]);
9995 digest
[4] = byte_swap_32 (digest
[4]);
9996 digest
[5] = byte_swap_32 (digest
[5]);
9998 digest
[5] &= ~0xff; // its just 23 not 24 !
10000 return (PARSER_OK
);
10003 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10005 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10007 u32
*digest
= (u32
*) hash_buf
->digest
;
10009 u8 tmp_buf
[100] = { 0 };
10011 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10013 memcpy (digest
, tmp_buf
, 32);
10015 digest
[0] = byte_swap_32 (digest
[0]);
10016 digest
[1] = byte_swap_32 (digest
[1]);
10017 digest
[2] = byte_swap_32 (digest
[2]);
10018 digest
[3] = byte_swap_32 (digest
[3]);
10019 digest
[4] = byte_swap_32 (digest
[4]);
10020 digest
[5] = byte_swap_32 (digest
[5]);
10021 digest
[6] = byte_swap_32 (digest
[6]);
10022 digest
[7] = byte_swap_32 (digest
[7]);
10024 digest
[0] -= SHA256M_A
;
10025 digest
[1] -= SHA256M_B
;
10026 digest
[2] -= SHA256M_C
;
10027 digest
[3] -= SHA256M_D
;
10028 digest
[4] -= SHA256M_E
;
10029 digest
[5] -= SHA256M_F
;
10030 digest
[6] -= SHA256M_G
;
10031 digest
[7] -= SHA256M_H
;
10033 return (PARSER_OK
);
10036 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10038 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10040 u32
*digest
= (u32
*) hash_buf
->digest
;
10042 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10043 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10045 digest
[0] = byte_swap_32 (digest
[0]);
10046 digest
[1] = byte_swap_32 (digest
[1]);
10050 IP (digest
[0], digest
[1], tt
);
10052 digest
[0] = digest
[0];
10053 digest
[1] = digest
[1];
10057 return (PARSER_OK
);
10060 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10062 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10064 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10066 u32
*digest
= (u32
*) hash_buf
->digest
;
10068 salt_t
*salt
= hash_buf
->salt
;
10070 char *hash_pos
= input_buf
+ 10;
10072 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10073 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10074 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10075 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10076 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10078 digest
[0] -= SHA1M_A
;
10079 digest
[1] -= SHA1M_B
;
10080 digest
[2] -= SHA1M_C
;
10081 digest
[3] -= SHA1M_D
;
10082 digest
[4] -= SHA1M_E
;
10084 uint salt_len
= 10;
10086 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10088 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10090 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10092 salt
->salt_len
= salt_len
;
10094 return (PARSER_OK
);
10097 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10099 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10101 u32
*digest
= (u32
*) hash_buf
->digest
;
10103 salt_t
*salt
= hash_buf
->salt
;
10105 char *hash_pos
= input_buf
+ 8;
10107 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10108 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10109 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10110 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10111 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10113 digest
[0] -= SHA1M_A
;
10114 digest
[1] -= SHA1M_B
;
10115 digest
[2] -= SHA1M_C
;
10116 digest
[3] -= SHA1M_D
;
10117 digest
[4] -= SHA1M_E
;
10121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10123 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10125 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10127 salt
->salt_len
= salt_len
;
10129 return (PARSER_OK
);
10132 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10134 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10136 u64
*digest
= (u64
*) hash_buf
->digest
;
10138 salt_t
*salt
= hash_buf
->salt
;
10140 char *hash_pos
= input_buf
+ 8;
10142 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10143 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10144 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10145 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10146 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10147 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10148 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10149 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10151 digest
[0] -= SHA512M_A
;
10152 digest
[1] -= SHA512M_B
;
10153 digest
[2] -= SHA512M_C
;
10154 digest
[3] -= SHA512M_D
;
10155 digest
[4] -= SHA512M_E
;
10156 digest
[5] -= SHA512M_F
;
10157 digest
[6] -= SHA512M_G
;
10158 digest
[7] -= SHA512M_H
;
10162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10164 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10166 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10168 salt
->salt_len
= salt_len
;
10170 return (PARSER_OK
);
10173 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10175 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10177 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10181 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10184 u32
*digest
= (u32
*) hash_buf
->digest
;
10186 salt_t
*salt
= hash_buf
->salt
;
10188 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10189 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10190 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10191 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10193 digest
[0] = byte_swap_32 (digest
[0]);
10194 digest
[1] = byte_swap_32 (digest
[1]);
10195 digest
[2] = byte_swap_32 (digest
[2]);
10196 digest
[3] = byte_swap_32 (digest
[3]);
10198 digest
[0] -= MD5M_A
;
10199 digest
[1] -= MD5M_B
;
10200 digest
[2] -= MD5M_C
;
10201 digest
[3] -= MD5M_D
;
10203 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10205 uint salt_len
= input_len
- 32 - 1;
10207 char *salt_buf
= input_buf
+ 32 + 1;
10209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10215 salt
->salt_len
= salt_len
;
10217 return (PARSER_OK
);
10220 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10222 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10224 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10228 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10233 char clean_input_buf
[32] = { 0 };
10235 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10236 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10238 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10242 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10248 clean_input_buf
[k
] = input_buf
[i
];
10256 u32
*digest
= (u32
*) hash_buf
->digest
;
10258 salt_t
*salt
= hash_buf
->salt
;
10260 u32 a
, b
, c
, d
, e
, f
;
10262 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10263 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10264 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10265 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10266 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10267 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10269 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10270 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10272 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10273 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10274 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10275 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10276 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10277 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10279 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10280 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10282 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10283 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10284 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10285 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10286 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10287 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10289 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10290 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10292 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10293 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10294 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10295 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10296 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10297 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10299 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10300 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10302 digest
[0] = byte_swap_32 (digest
[0]);
10303 digest
[1] = byte_swap_32 (digest
[1]);
10304 digest
[2] = byte_swap_32 (digest
[2]);
10305 digest
[3] = byte_swap_32 (digest
[3]);
10307 digest
[0] -= MD5M_A
;
10308 digest
[1] -= MD5M_B
;
10309 digest
[2] -= MD5M_C
;
10310 digest
[3] -= MD5M_D
;
10312 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10314 uint salt_len
= input_len
- 30 - 1;
10316 char *salt_buf
= input_buf
+ 30 + 1;
10318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10322 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10323 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10325 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10327 salt
->salt_len
= salt_len
;
10329 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10331 salt
->salt_len
+= 22;
10333 return (PARSER_OK
);
10336 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10340 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10344 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10347 u32
*digest
= (u32
*) hash_buf
->digest
;
10349 salt_t
*salt
= hash_buf
->salt
;
10351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10353 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10354 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10355 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10357 digest
[0] -= SHA1M_A
;
10358 digest
[1] -= SHA1M_B
;
10359 digest
[2] -= SHA1M_C
;
10360 digest
[3] -= SHA1M_D
;
10361 digest
[4] -= SHA1M_E
;
10363 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10365 uint salt_len
= input_len
- 40 - 1;
10367 char *salt_buf
= input_buf
+ 40 + 1;
10369 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10371 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10373 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10375 salt
->salt_len
= salt_len
;
10377 return (PARSER_OK
);
10380 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10382 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10384 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10388 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10391 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10393 char *iter_pos
= input_buf
+ 6;
10395 salt_t
*salt
= hash_buf
->salt
;
10397 uint iter
= atoi (iter_pos
);
10401 iter
= ROUNDS_DCC2
;
10404 salt
->salt_iter
= iter
- 1;
10406 char *salt_pos
= strchr (iter_pos
, '#');
10408 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10412 char *digest_pos
= strchr (salt_pos
, '#');
10414 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10418 uint salt_len
= digest_pos
- salt_pos
- 1;
10420 u32
*digest
= (u32
*) hash_buf
->digest
;
10422 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10423 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10424 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10425 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10427 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10429 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10431 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10433 salt
->salt_len
= salt_len
;
10435 return (PARSER_OK
);
10438 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10440 u32
*digest
= (u32
*) hash_buf
->digest
;
10442 salt_t
*salt
= hash_buf
->salt
;
10444 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10448 memcpy (&in
, input_buf
, input_len
);
10450 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10452 memcpy (digest
, in
.keymic
, 16);
10455 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10456 The phrase "Pairwise key expansion"
10457 Access Point Address (referred to as Authenticator Address AA)
10458 Supplicant Address (referred to as Supplicant Address SA)
10459 Access Point Nonce (referred to as Authenticator Anonce)
10460 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10463 uint salt_len
= strlen (in
.essid
);
10467 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10469 return (PARSER_SALT_LENGTH
);
10472 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10474 salt
->salt_len
= salt_len
;
10476 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10478 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10480 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10482 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10484 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10485 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10489 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10490 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10493 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10495 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10496 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10500 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10501 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10504 for (int i
= 0; i
< 25; i
++)
10506 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10509 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10510 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10511 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10512 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10514 wpa
->keyver
= in
.keyver
;
10516 if (wpa
->keyver
> 255)
10518 log_info ("ATTENTION!");
10519 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10520 log_info (" This could be due to a recent aircrack-ng bug.");
10521 log_info (" The key version was automatically reset to a reasonable value.");
10524 wpa
->keyver
&= 0xff;
10527 wpa
->eapol_size
= in
.eapol_size
;
10529 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10531 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10533 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10535 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10537 if (wpa
->keyver
== 1)
10543 digest
[0] = byte_swap_32 (digest
[0]);
10544 digest
[1] = byte_swap_32 (digest
[1]);
10545 digest
[2] = byte_swap_32 (digest
[2]);
10546 digest
[3] = byte_swap_32 (digest
[3]);
10548 for (int i
= 0; i
< 64; i
++)
10550 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10554 uint32_t *p0
= (uint32_t *) in
.essid
;
10558 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10559 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10561 salt
->salt_buf
[10] = c0
;
10562 salt
->salt_buf
[11] = c1
;
10564 return (PARSER_OK
);
10567 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10569 u32
*digest
= (u32
*) hash_buf
->digest
;
10571 salt_t
*salt
= hash_buf
->salt
;
10573 if (input_len
== 0)
10575 log_error ("Password Safe v2 container not specified");
10580 FILE *fp
= fopen (input_buf
, "rb");
10584 log_error ("%s: %s", input_buf
, strerror (errno
));
10591 memset (&buf
, 0, sizeof (psafe2_hdr
));
10593 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10597 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10599 salt
->salt_buf
[0] = buf
.random
[0];
10600 salt
->salt_buf
[1] = buf
.random
[1];
10602 salt
->salt_len
= 8;
10603 salt
->salt_iter
= 1000;
10605 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10606 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10607 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10608 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10609 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10611 return (PARSER_OK
);
10614 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10616 u32
*digest
= (u32
*) hash_buf
->digest
;
10618 salt_t
*salt
= hash_buf
->salt
;
10620 if (input_len
== 0)
10622 log_error (".psafe3 not specified");
10627 FILE *fp
= fopen (input_buf
, "rb");
10631 log_error ("%s: %s", input_buf
, strerror (errno
));
10638 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10642 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10644 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10646 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10648 salt
->salt_iter
= in
.iterations
+ 1;
10650 salt
->salt_buf
[0] = in
.salt_buf
[0];
10651 salt
->salt_buf
[1] = in
.salt_buf
[1];
10652 salt
->salt_buf
[2] = in
.salt_buf
[2];
10653 salt
->salt_buf
[3] = in
.salt_buf
[3];
10654 salt
->salt_buf
[4] = in
.salt_buf
[4];
10655 salt
->salt_buf
[5] = in
.salt_buf
[5];
10656 salt
->salt_buf
[6] = in
.salt_buf
[6];
10657 salt
->salt_buf
[7] = in
.salt_buf
[7];
10659 salt
->salt_len
= 32;
10661 digest
[0] = in
.hash_buf
[0];
10662 digest
[1] = in
.hash_buf
[1];
10663 digest
[2] = in
.hash_buf
[2];
10664 digest
[3] = in
.hash_buf
[3];
10665 digest
[4] = in
.hash_buf
[4];
10666 digest
[5] = in
.hash_buf
[5];
10667 digest
[6] = in
.hash_buf
[6];
10668 digest
[7] = in
.hash_buf
[7];
10670 digest
[0] = byte_swap_32 (digest
[0]);
10671 digest
[1] = byte_swap_32 (digest
[1]);
10672 digest
[2] = byte_swap_32 (digest
[2]);
10673 digest
[3] = byte_swap_32 (digest
[3]);
10674 digest
[4] = byte_swap_32 (digest
[4]);
10675 digest
[5] = byte_swap_32 (digest
[5]);
10676 digest
[6] = byte_swap_32 (digest
[6]);
10677 digest
[7] = byte_swap_32 (digest
[7]);
10679 return (PARSER_OK
);
10682 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10684 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10686 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10688 u32
*digest
= (u32
*) hash_buf
->digest
;
10690 salt_t
*salt
= hash_buf
->salt
;
10692 char *iter_pos
= input_buf
+ 3;
10694 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10696 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10698 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10700 salt
->salt_iter
= salt_iter
;
10702 char *salt_pos
= iter_pos
+ 1;
10706 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10708 salt
->salt_len
= salt_len
;
10710 char *hash_pos
= salt_pos
+ salt_len
;
10712 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10714 return (PARSER_OK
);
10717 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10719 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10721 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10723 u32
*digest
= (u32
*) hash_buf
->digest
;
10725 salt_t
*salt
= hash_buf
->salt
;
10727 char *salt_pos
= input_buf
+ 3;
10729 uint iterations_len
= 0;
10731 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10735 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10737 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10738 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10742 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10746 iterations_len
+= 8;
10750 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10753 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10755 char *hash_pos
= strchr (salt_pos
, '$');
10757 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10759 uint salt_len
= hash_pos
- salt_pos
;
10761 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10763 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10765 salt
->salt_len
= salt_len
;
10769 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10771 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10773 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10775 return (PARSER_OK
);
10778 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10780 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10782 u32
*digest
= (u32
*) hash_buf
->digest
;
10784 salt_t
*salt
= hash_buf
->salt
;
10786 char *salt_pos
= input_buf
+ 6;
10788 uint iterations_len
= 0;
10790 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10794 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10796 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10797 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10801 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10805 iterations_len
+= 8;
10809 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10812 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10814 char *hash_pos
= strchr (salt_pos
, '$');
10816 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10818 uint salt_len
= hash_pos
- salt_pos
;
10820 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10822 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10824 salt
->salt_len
= salt_len
;
10828 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10830 return (PARSER_OK
);
10833 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10835 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10837 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10839 u32
*digest
= (u32
*) hash_buf
->digest
;
10841 salt_t
*salt
= hash_buf
->salt
;
10843 char *salt_pos
= input_buf
+ 14;
10845 char *hash_pos
= strchr (salt_pos
, '*');
10847 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10851 uint salt_len
= hash_pos
- salt_pos
- 1;
10853 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10855 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10857 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10859 salt
->salt_len
= salt_len
;
10861 u8 tmp_buf
[100] = { 0 };
10863 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10865 memcpy (digest
, tmp_buf
, 20);
10867 digest
[0] = byte_swap_32 (digest
[0]);
10868 digest
[1] = byte_swap_32 (digest
[1]);
10869 digest
[2] = byte_swap_32 (digest
[2]);
10870 digest
[3] = byte_swap_32 (digest
[3]);
10871 digest
[4] = byte_swap_32 (digest
[4]);
10873 digest
[0] -= SHA1M_A
;
10874 digest
[1] -= SHA1M_B
;
10875 digest
[2] -= SHA1M_C
;
10876 digest
[3] -= SHA1M_D
;
10877 digest
[4] -= SHA1M_E
;
10879 return (PARSER_OK
);
10882 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10884 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10886 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10888 if (c12
& 3) return (PARSER_HASH_VALUE
);
10890 u32
*digest
= (u32
*) hash_buf
->digest
;
10892 salt_t
*salt
= hash_buf
->salt
;
10894 // for ascii_digest
10895 salt
->salt_sign
[0] = input_buf
[0];
10896 salt
->salt_sign
[1] = input_buf
[1];
10898 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10899 | itoa64_to_int (input_buf
[1]) << 6;
10901 salt
->salt_len
= 2;
10903 u8 tmp_buf
[100] = { 0 };
10905 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10907 memcpy (digest
, tmp_buf
, 8);
10911 IP (digest
[0], digest
[1], tt
);
10916 return (PARSER_OK
);
10919 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10921 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10923 u32
*digest
= (u32
*) hash_buf
->digest
;
10925 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10926 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10927 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10928 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10930 digest
[0] = byte_swap_32 (digest
[0]);
10931 digest
[1] = byte_swap_32 (digest
[1]);
10932 digest
[2] = byte_swap_32 (digest
[2]);
10933 digest
[3] = byte_swap_32 (digest
[3]);
10935 digest
[0] -= MD4M_A
;
10936 digest
[1] -= MD4M_B
;
10937 digest
[2] -= MD4M_C
;
10938 digest
[3] -= MD4M_D
;
10940 return (PARSER_OK
);
10943 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10945 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10947 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10951 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10954 u32
*digest
= (u32
*) hash_buf
->digest
;
10956 salt_t
*salt
= hash_buf
->salt
;
10958 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10959 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10960 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10961 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10963 digest
[0] = byte_swap_32 (digest
[0]);
10964 digest
[1] = byte_swap_32 (digest
[1]);
10965 digest
[2] = byte_swap_32 (digest
[2]);
10966 digest
[3] = byte_swap_32 (digest
[3]);
10968 digest
[0] -= MD4M_A
;
10969 digest
[1] -= MD4M_B
;
10970 digest
[2] -= MD4M_C
;
10971 digest
[3] -= MD4M_D
;
10973 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10975 uint salt_len
= input_len
- 32 - 1;
10977 char *salt_buf
= input_buf
+ 32 + 1;
10979 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10981 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10983 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10985 salt
->salt_len
= salt_len
;
10987 return (PARSER_OK
);
10990 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10992 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10994 u32
*digest
= (u32
*) hash_buf
->digest
;
10996 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10997 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10998 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10999 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11001 digest
[0] = byte_swap_32 (digest
[0]);
11002 digest
[1] = byte_swap_32 (digest
[1]);
11003 digest
[2] = byte_swap_32 (digest
[2]);
11004 digest
[3] = byte_swap_32 (digest
[3]);
11006 digest
[0] -= MD5M_A
;
11007 digest
[1] -= MD5M_B
;
11008 digest
[2] -= MD5M_C
;
11009 digest
[3] -= MD5M_D
;
11011 return (PARSER_OK
);
11014 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11016 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11018 u32
*digest
= (u32
*) hash_buf
->digest
;
11020 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11021 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11025 digest
[0] = byte_swap_32 (digest
[0]);
11026 digest
[1] = byte_swap_32 (digest
[1]);
11028 return (PARSER_OK
);
11031 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11033 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11035 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11039 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11042 u32
*digest
= (u32
*) hash_buf
->digest
;
11044 salt_t
*salt
= hash_buf
->salt
;
11046 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11047 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11048 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11049 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11051 digest
[0] = byte_swap_32 (digest
[0]);
11052 digest
[1] = byte_swap_32 (digest
[1]);
11053 digest
[2] = byte_swap_32 (digest
[2]);
11054 digest
[3] = byte_swap_32 (digest
[3]);
11056 digest
[0] -= MD5M_A
;
11057 digest
[1] -= MD5M_B
;
11058 digest
[2] -= MD5M_C
;
11059 digest
[3] -= MD5M_D
;
11061 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11063 uint salt_len
= input_len
- 32 - 1;
11065 char *salt_buf
= input_buf
+ 32 + 1;
11067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11073 salt
->salt_len
= salt_len
;
11075 return (PARSER_OK
);
11078 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11080 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11082 u32
*digest
= (u32
*) hash_buf
->digest
;
11084 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11085 | itoa64_to_int (input_buf
[ 1]) << 6
11086 | itoa64_to_int (input_buf
[ 2]) << 12
11087 | itoa64_to_int (input_buf
[ 3]) << 18;
11088 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11089 | itoa64_to_int (input_buf
[ 5]) << 6
11090 | itoa64_to_int (input_buf
[ 6]) << 12
11091 | itoa64_to_int (input_buf
[ 7]) << 18;
11092 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11093 | itoa64_to_int (input_buf
[ 9]) << 6
11094 | itoa64_to_int (input_buf
[10]) << 12
11095 | itoa64_to_int (input_buf
[11]) << 18;
11096 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11097 | itoa64_to_int (input_buf
[13]) << 6
11098 | itoa64_to_int (input_buf
[14]) << 12
11099 | itoa64_to_int (input_buf
[15]) << 18;
11101 digest
[0] -= MD5M_A
;
11102 digest
[1] -= MD5M_B
;
11103 digest
[2] -= MD5M_C
;
11104 digest
[3] -= MD5M_D
;
11106 digest
[0] &= 0x00ffffff;
11107 digest
[1] &= 0x00ffffff;
11108 digest
[2] &= 0x00ffffff;
11109 digest
[3] &= 0x00ffffff;
11111 return (PARSER_OK
);
11114 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11116 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11118 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11122 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11125 u32
*digest
= (u32
*) hash_buf
->digest
;
11127 salt_t
*salt
= hash_buf
->salt
;
11129 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11130 | itoa64_to_int (input_buf
[ 1]) << 6
11131 | itoa64_to_int (input_buf
[ 2]) << 12
11132 | itoa64_to_int (input_buf
[ 3]) << 18;
11133 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11134 | itoa64_to_int (input_buf
[ 5]) << 6
11135 | itoa64_to_int (input_buf
[ 6]) << 12
11136 | itoa64_to_int (input_buf
[ 7]) << 18;
11137 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11138 | itoa64_to_int (input_buf
[ 9]) << 6
11139 | itoa64_to_int (input_buf
[10]) << 12
11140 | itoa64_to_int (input_buf
[11]) << 18;
11141 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11142 | itoa64_to_int (input_buf
[13]) << 6
11143 | itoa64_to_int (input_buf
[14]) << 12
11144 | itoa64_to_int (input_buf
[15]) << 18;
11146 digest
[0] -= MD5M_A
;
11147 digest
[1] -= MD5M_B
;
11148 digest
[2] -= MD5M_C
;
11149 digest
[3] -= MD5M_D
;
11151 digest
[0] &= 0x00ffffff;
11152 digest
[1] &= 0x00ffffff;
11153 digest
[2] &= 0x00ffffff;
11154 digest
[3] &= 0x00ffffff;
11156 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11158 uint salt_len
= input_len
- 16 - 1;
11160 char *salt_buf
= input_buf
+ 16 + 1;
11162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11164 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11166 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11168 salt
->salt_len
= salt_len
;
11170 return (PARSER_OK
);
11173 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11175 key
[0] = (nthash
[0] >> 0);
11176 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11177 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11178 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11179 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11180 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11181 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11182 key
[7] = (nthash
[6] << 1);
11194 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11196 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11198 u32
*digest
= (u32
*) hash_buf
->digest
;
11200 salt_t
*salt
= hash_buf
->salt
;
11202 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11208 char *user_pos
= input_buf
;
11210 char *unused_pos
= strchr (user_pos
, ':');
11212 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11214 uint user_len
= unused_pos
- user_pos
;
11216 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11220 char *domain_pos
= strchr (unused_pos
, ':');
11222 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11224 uint unused_len
= domain_pos
- unused_pos
;
11226 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11230 char *srvchall_pos
= strchr (domain_pos
, ':');
11232 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11234 uint domain_len
= srvchall_pos
- domain_pos
;
11236 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11240 char *hash_pos
= strchr (srvchall_pos
, ':');
11242 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11244 uint srvchall_len
= hash_pos
- srvchall_pos
;
11246 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11250 char *clichall_pos
= strchr (hash_pos
, ':');
11252 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11254 uint hash_len
= clichall_pos
- hash_pos
;
11256 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11260 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11262 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11265 * store some data for later use
11268 netntlm
->user_len
= user_len
* 2;
11269 netntlm
->domain_len
= domain_len
* 2;
11270 netntlm
->srvchall_len
= srvchall_len
/ 2;
11271 netntlm
->clichall_len
= clichall_len
/ 2;
11273 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11274 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11277 * handle username and domainname
11280 for (uint i
= 0; i
< user_len
; i
++)
11282 *userdomain_ptr
++ = user_pos
[i
];
11283 *userdomain_ptr
++ = 0;
11286 for (uint i
= 0; i
< domain_len
; i
++)
11288 *userdomain_ptr
++ = domain_pos
[i
];
11289 *userdomain_ptr
++ = 0;
11293 * handle server challenge encoding
11296 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11298 const char p0
= srvchall_pos
[i
+ 0];
11299 const char p1
= srvchall_pos
[i
+ 1];
11301 *chall_ptr
++ = hex_convert (p1
) << 0
11302 | hex_convert (p0
) << 4;
11306 * handle client challenge encoding
11309 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11311 const char p0
= clichall_pos
[i
+ 0];
11312 const char p1
= clichall_pos
[i
+ 1];
11314 *chall_ptr
++ = hex_convert (p1
) << 0
11315 | hex_convert (p0
) << 4;
11322 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11324 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11328 salt
->salt_len
= salt_len
;
11330 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11331 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11332 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11333 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11335 digest
[0] = byte_swap_32 (digest
[0]);
11336 digest
[1] = byte_swap_32 (digest
[1]);
11337 digest
[2] = byte_swap_32 (digest
[2]);
11338 digest
[3] = byte_swap_32 (digest
[3]);
11340 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11342 uint digest_tmp
[2] = { 0 };
11344 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11345 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11347 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11348 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11350 /* special case 2: ESS */
11352 if (srvchall_len
== 48)
11354 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11356 uint w
[16] = { 0 };
11358 w
[ 0] = netntlm
->chall_buf
[6];
11359 w
[ 1] = netntlm
->chall_buf
[7];
11360 w
[ 2] = netntlm
->chall_buf
[0];
11361 w
[ 3] = netntlm
->chall_buf
[1];
11365 uint dgst
[4] = { 0 };
11374 salt
->salt_buf
[0] = dgst
[0];
11375 salt
->salt_buf
[1] = dgst
[1];
11379 /* precompute netntlmv1 exploit start */
11381 for (uint i
= 0; i
< 0x10000; i
++)
11383 uint key_md4
[2] = { i
, 0 };
11384 uint key_des
[2] = { 0, 0 };
11386 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11388 uint Kc
[16] = { 0 };
11389 uint Kd
[16] = { 0 };
11391 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11393 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11395 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11397 if (data3
[0] != digest_tmp
[0]) continue;
11398 if (data3
[1] != digest_tmp
[1]) continue;
11400 salt
->salt_buf
[2] = i
;
11402 salt
->salt_len
= 24;
11407 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11408 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11410 /* precompute netntlmv1 exploit stop */
11414 IP (digest
[0], digest
[1], tt
);
11415 IP (digest
[2], digest
[3], tt
);
11417 digest
[0] = rotr32 (digest
[0], 29);
11418 digest
[1] = rotr32 (digest
[1], 29);
11419 digest
[2] = rotr32 (digest
[2], 29);
11420 digest
[3] = rotr32 (digest
[3], 29);
11422 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11424 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11425 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11427 return (PARSER_OK
);
11430 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11432 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11434 u32
*digest
= (u32
*) hash_buf
->digest
;
11436 salt_t
*salt
= hash_buf
->salt
;
11438 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11444 char *user_pos
= input_buf
;
11446 char *unused_pos
= strchr (user_pos
, ':');
11448 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11450 uint user_len
= unused_pos
- user_pos
;
11452 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11456 char *domain_pos
= strchr (unused_pos
, ':');
11458 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11460 uint unused_len
= domain_pos
- unused_pos
;
11462 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11466 char *srvchall_pos
= strchr (domain_pos
, ':');
11468 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11470 uint domain_len
= srvchall_pos
- domain_pos
;
11472 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11476 char *hash_pos
= strchr (srvchall_pos
, ':');
11478 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11480 uint srvchall_len
= hash_pos
- srvchall_pos
;
11482 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11486 char *clichall_pos
= strchr (hash_pos
, ':');
11488 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11490 uint hash_len
= clichall_pos
- hash_pos
;
11492 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11496 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11498 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11500 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11503 * store some data for later use
11506 netntlm
->user_len
= user_len
* 2;
11507 netntlm
->domain_len
= domain_len
* 2;
11508 netntlm
->srvchall_len
= srvchall_len
/ 2;
11509 netntlm
->clichall_len
= clichall_len
/ 2;
11511 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11512 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11515 * handle username and domainname
11518 for (uint i
= 0; i
< user_len
; i
++)
11520 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11521 *userdomain_ptr
++ = 0;
11524 for (uint i
= 0; i
< domain_len
; i
++)
11526 *userdomain_ptr
++ = domain_pos
[i
];
11527 *userdomain_ptr
++ = 0;
11530 *userdomain_ptr
++ = 0x80;
11533 * handle server challenge encoding
11536 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11538 const char p0
= srvchall_pos
[i
+ 0];
11539 const char p1
= srvchall_pos
[i
+ 1];
11541 *chall_ptr
++ = hex_convert (p1
) << 0
11542 | hex_convert (p0
) << 4;
11546 * handle client challenge encoding
11549 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11551 const char p0
= clichall_pos
[i
+ 0];
11552 const char p1
= clichall_pos
[i
+ 1];
11554 *chall_ptr
++ = hex_convert (p1
) << 0
11555 | hex_convert (p0
) << 4;
11558 *chall_ptr
++ = 0x80;
11561 * handle hash itself
11564 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11565 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11566 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11567 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11569 digest
[0] = byte_swap_32 (digest
[0]);
11570 digest
[1] = byte_swap_32 (digest
[1]);
11571 digest
[2] = byte_swap_32 (digest
[2]);
11572 digest
[3] = byte_swap_32 (digest
[3]);
11575 * reuse challange data as salt_buf, its the buffer that is most likely unique
11578 salt
->salt_buf
[0] = 0;
11579 salt
->salt_buf
[1] = 0;
11580 salt
->salt_buf
[2] = 0;
11581 salt
->salt_buf
[3] = 0;
11582 salt
->salt_buf
[4] = 0;
11583 salt
->salt_buf
[5] = 0;
11584 salt
->salt_buf
[6] = 0;
11585 salt
->salt_buf
[7] = 0;
11589 uptr
= (uint
*) netntlm
->userdomain_buf
;
11591 for (uint i
= 0; i
< 16; i
+= 16)
11593 md5_64 (uptr
, salt
->salt_buf
);
11596 uptr
= (uint
*) netntlm
->chall_buf
;
11598 for (uint i
= 0; i
< 256; i
+= 16)
11600 md5_64 (uptr
, salt
->salt_buf
);
11603 salt
->salt_len
= 16;
11605 return (PARSER_OK
);
11608 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11610 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11612 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11616 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11619 u32
*digest
= (u32
*) hash_buf
->digest
;
11621 salt_t
*salt
= hash_buf
->salt
;
11623 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11624 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11625 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11626 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11628 digest
[0] = byte_swap_32 (digest
[0]);
11629 digest
[1] = byte_swap_32 (digest
[1]);
11630 digest
[2] = byte_swap_32 (digest
[2]);
11631 digest
[3] = byte_swap_32 (digest
[3]);
11633 digest
[0] -= MD5M_A
;
11634 digest
[1] -= MD5M_B
;
11635 digest
[2] -= MD5M_C
;
11636 digest
[3] -= MD5M_D
;
11638 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11640 uint salt_len
= input_len
- 32 - 1;
11642 char *salt_buf
= input_buf
+ 32 + 1;
11644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11646 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11648 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11650 salt
->salt_len
= salt_len
;
11652 return (PARSER_OK
);
11655 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11657 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11659 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11663 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11666 u32
*digest
= (u32
*) hash_buf
->digest
;
11668 salt_t
*salt
= hash_buf
->salt
;
11670 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11671 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11672 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11673 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11675 digest
[0] = byte_swap_32 (digest
[0]);
11676 digest
[1] = byte_swap_32 (digest
[1]);
11677 digest
[2] = byte_swap_32 (digest
[2]);
11678 digest
[3] = byte_swap_32 (digest
[3]);
11680 digest
[0] -= MD5M_A
;
11681 digest
[1] -= MD5M_B
;
11682 digest
[2] -= MD5M_C
;
11683 digest
[3] -= MD5M_D
;
11685 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11687 uint salt_len
= input_len
- 32 - 1;
11689 char *salt_buf
= input_buf
+ 32 + 1;
11691 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11693 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11695 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11697 salt
->salt_len
= salt_len
;
11699 return (PARSER_OK
);
11702 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11704 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11706 u32
*digest
= (u32
*) hash_buf
->digest
;
11708 salt_t
*salt
= hash_buf
->salt
;
11710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11715 digest
[0] = byte_swap_32 (digest
[0]);
11716 digest
[1] = byte_swap_32 (digest
[1]);
11717 digest
[2] = byte_swap_32 (digest
[2]);
11718 digest
[3] = byte_swap_32 (digest
[3]);
11720 digest
[0] -= MD5M_A
;
11721 digest
[1] -= MD5M_B
;
11722 digest
[2] -= MD5M_C
;
11723 digest
[3] -= MD5M_D
;
11726 * This is a virtual salt. While the algorithm is basically not salted
11727 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11728 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11733 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11737 salt
->salt_len
= salt_len
;
11739 return (PARSER_OK
);
11742 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11744 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11746 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11750 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11753 u32
*digest
= (u32
*) hash_buf
->digest
;
11755 salt_t
*salt
= hash_buf
->salt
;
11757 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11758 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11759 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11760 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11762 digest
[0] = byte_swap_32 (digest
[0]);
11763 digest
[1] = byte_swap_32 (digest
[1]);
11764 digest
[2] = byte_swap_32 (digest
[2]);
11765 digest
[3] = byte_swap_32 (digest
[3]);
11767 digest
[0] -= MD5M_A
;
11768 digest
[1] -= MD5M_B
;
11769 digest
[2] -= MD5M_C
;
11770 digest
[3] -= MD5M_D
;
11772 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11774 uint salt_len
= input_len
- 32 - 1;
11776 char *salt_buf
= input_buf
+ 32 + 1;
11778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11780 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11782 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11784 salt
->salt_len
= salt_len
;
11786 return (PARSER_OK
);
11789 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11791 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11793 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11797 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11800 u32
*digest
= (u32
*) hash_buf
->digest
;
11802 salt_t
*salt
= hash_buf
->salt
;
11804 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11805 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11806 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11807 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11809 digest
[0] = byte_swap_32 (digest
[0]);
11810 digest
[1] = byte_swap_32 (digest
[1]);
11811 digest
[2] = byte_swap_32 (digest
[2]);
11812 digest
[3] = byte_swap_32 (digest
[3]);
11814 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11816 uint salt_len
= input_len
- 32 - 1;
11818 char *salt_buf
= input_buf
+ 32 + 1;
11820 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11822 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11824 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11826 salt
->salt_len
= salt_len
;
11828 return (PARSER_OK
);
11831 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11833 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11835 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11839 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11842 u32
*digest
= (u32
*) hash_buf
->digest
;
11844 salt_t
*salt
= hash_buf
->salt
;
11846 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11847 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11848 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11849 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11851 digest
[0] = byte_swap_32 (digest
[0]);
11852 digest
[1] = byte_swap_32 (digest
[1]);
11853 digest
[2] = byte_swap_32 (digest
[2]);
11854 digest
[3] = byte_swap_32 (digest
[3]);
11856 digest
[0] -= MD4M_A
;
11857 digest
[1] -= MD4M_B
;
11858 digest
[2] -= MD4M_C
;
11859 digest
[3] -= MD4M_D
;
11861 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11863 uint salt_len
= input_len
- 32 - 1;
11865 char *salt_buf
= input_buf
+ 32 + 1;
11867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11869 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11871 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11873 salt
->salt_len
= salt_len
;
11875 return (PARSER_OK
);
11878 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11880 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11882 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11886 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11889 u32
*digest
= (u32
*) hash_buf
->digest
;
11891 salt_t
*salt
= hash_buf
->salt
;
11893 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11894 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11895 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11896 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11898 digest
[0] = byte_swap_32 (digest
[0]);
11899 digest
[1] = byte_swap_32 (digest
[1]);
11900 digest
[2] = byte_swap_32 (digest
[2]);
11901 digest
[3] = byte_swap_32 (digest
[3]);
11903 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11905 uint salt_len
= input_len
- 32 - 1;
11907 char *salt_buf
= input_buf
+ 32 + 1;
11909 uint salt_pc_block
[16] = { 0 };
11911 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11913 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11915 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11917 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11919 salt_pc_block
[14] = salt_len
* 8;
11921 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11923 md5_64 (salt_pc_block
, salt_pc_digest
);
11925 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11926 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11927 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11928 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11930 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11932 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11934 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11936 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11937 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11938 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11939 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11941 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11943 return (PARSER_OK
);
11946 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11948 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11950 u32
*digest
= (u32
*) hash_buf
->digest
;
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 return (PARSER_OK
);
11967 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11969 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11971 u32
*digest
= (u32
*) hash_buf
->digest
;
11973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11975 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11976 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11977 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11979 return (PARSER_OK
);
11982 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11984 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11986 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11988 u32
*digest
= (u32
*) hash_buf
->digest
;
11992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11996 digest
[4] = 0x00000000;
11998 return (PARSER_OK
);
12001 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12003 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12005 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12009 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12012 u32
*digest
= (u32
*) hash_buf
->digest
;
12014 salt_t
*salt
= hash_buf
->salt
;
12016 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12017 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12018 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12019 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12020 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12022 digest
[0] -= SHA1M_A
;
12023 digest
[1] -= SHA1M_B
;
12024 digest
[2] -= SHA1M_C
;
12025 digest
[3] -= SHA1M_D
;
12026 digest
[4] -= SHA1M_E
;
12028 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12030 uint salt_len
= input_len
- 40 - 1;
12032 char *salt_buf
= input_buf
+ 40 + 1;
12034 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12036 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12038 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12040 salt
->salt_len
= salt_len
;
12042 return (PARSER_OK
);
12045 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12047 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12049 u32
*digest
= (u32
*) hash_buf
->digest
;
12051 salt_t
*salt
= hash_buf
->salt
;
12053 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12055 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12056 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12057 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12058 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12059 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12061 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12063 uint salt_len
= input_len
- 40 - 1;
12065 char *salt_buf
= input_buf
+ 40 + 1;
12067 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12069 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12071 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12073 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12076 pstoken
->salt_len
= salt_len
/ 2;
12078 /* some fake salt for the sorting mechanisms */
12080 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12081 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12082 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12083 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12084 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12085 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12086 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12087 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12089 salt
->salt_len
= 32;
12091 /* we need to check if we can precompute some of the data --
12092 this is possible since the scheme is badly designed */
12094 pstoken
->pc_digest
[0] = SHA1M_A
;
12095 pstoken
->pc_digest
[1] = SHA1M_B
;
12096 pstoken
->pc_digest
[2] = SHA1M_C
;
12097 pstoken
->pc_digest
[3] = SHA1M_D
;
12098 pstoken
->pc_digest
[4] = SHA1M_E
;
12100 pstoken
->pc_offset
= 0;
12102 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12106 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12107 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12108 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12109 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12110 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12111 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12112 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12113 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12114 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12115 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12116 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12117 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12118 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12119 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12120 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12121 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12123 sha1_64 (w
, pstoken
->pc_digest
);
12125 pstoken
->pc_offset
+= 16;
12128 return (PARSER_OK
);
12131 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12133 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12135 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12137 u32
*digest
= (u32
*) hash_buf
->digest
;
12139 u8 tmp_buf
[100] = { 0 };
12141 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12143 memcpy (digest
, tmp_buf
, 20);
12145 digest
[0] = byte_swap_32 (digest
[0]);
12146 digest
[1] = byte_swap_32 (digest
[1]);
12147 digest
[2] = byte_swap_32 (digest
[2]);
12148 digest
[3] = byte_swap_32 (digest
[3]);
12149 digest
[4] = byte_swap_32 (digest
[4]);
12151 digest
[0] -= SHA1M_A
;
12152 digest
[1] -= SHA1M_B
;
12153 digest
[2] -= SHA1M_C
;
12154 digest
[3] -= SHA1M_D
;
12155 digest
[4] -= SHA1M_E
;
12157 return (PARSER_OK
);
12160 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12162 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12164 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12166 u32
*digest
= (u32
*) hash_buf
->digest
;
12168 salt_t
*salt
= hash_buf
->salt
;
12170 u8 tmp_buf
[100] = { 0 };
12172 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12174 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12176 memcpy (digest
, tmp_buf
, 20);
12178 int salt_len
= tmp_len
- 20;
12180 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12182 salt
->salt_len
= salt_len
;
12184 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12186 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12188 char *ptr
= (char *) salt
->salt_buf
;
12190 ptr
[salt
->salt_len
] = 0x80;
12193 digest
[0] = byte_swap_32 (digest
[0]);
12194 digest
[1] = byte_swap_32 (digest
[1]);
12195 digest
[2] = byte_swap_32 (digest
[2]);
12196 digest
[3] = byte_swap_32 (digest
[3]);
12197 digest
[4] = byte_swap_32 (digest
[4]);
12199 digest
[0] -= SHA1M_A
;
12200 digest
[1] -= SHA1M_B
;
12201 digest
[2] -= SHA1M_C
;
12202 digest
[3] -= SHA1M_D
;
12203 digest
[4] -= SHA1M_E
;
12205 return (PARSER_OK
);
12208 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12210 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12212 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12214 u32
*digest
= (u32
*) hash_buf
->digest
;
12216 salt_t
*salt
= hash_buf
->salt
;
12218 char *salt_buf
= input_buf
+ 6;
12222 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12224 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12226 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12228 salt
->salt_len
= salt_len
;
12230 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12232 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12233 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12234 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12235 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12236 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12238 digest
[0] -= SHA1M_A
;
12239 digest
[1] -= SHA1M_B
;
12240 digest
[2] -= SHA1M_C
;
12241 digest
[3] -= SHA1M_D
;
12242 digest
[4] -= SHA1M_E
;
12244 return (PARSER_OK
);
12247 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12249 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12251 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12253 u32
*digest
= (u32
*) hash_buf
->digest
;
12255 salt_t
*salt
= hash_buf
->salt
;
12257 char *salt_buf
= input_buf
+ 6;
12261 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12265 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12267 salt
->salt_len
= salt_len
;
12269 char *hash_pos
= input_buf
+ 6 + 8;
12271 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12272 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12273 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12274 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12275 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12277 digest
[0] -= SHA1M_A
;
12278 digest
[1] -= SHA1M_B
;
12279 digest
[2] -= SHA1M_C
;
12280 digest
[3] -= SHA1M_D
;
12281 digest
[4] -= SHA1M_E
;
12283 return (PARSER_OK
);
12286 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12288 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12290 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12292 u64
*digest
= (u64
*) hash_buf
->digest
;
12294 salt_t
*salt
= hash_buf
->salt
;
12296 char *salt_buf
= input_buf
+ 6;
12300 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12302 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12304 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12306 salt
->salt_len
= salt_len
;
12308 char *hash_pos
= input_buf
+ 6 + 8;
12310 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12311 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12312 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12313 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12314 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12315 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12316 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12317 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12319 digest
[0] -= SHA512M_A
;
12320 digest
[1] -= SHA512M_B
;
12321 digest
[2] -= SHA512M_C
;
12322 digest
[3] -= SHA512M_D
;
12323 digest
[4] -= SHA512M_E
;
12324 digest
[5] -= SHA512M_F
;
12325 digest
[6] -= SHA512M_G
;
12326 digest
[7] -= SHA512M_H
;
12328 return (PARSER_OK
);
12331 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12333 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12335 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12339 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12342 u32
*digest
= (u32
*) hash_buf
->digest
;
12344 salt_t
*salt
= hash_buf
->salt
;
12346 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12347 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12351 digest
[0] = byte_swap_32 (digest
[0]);
12352 digest
[1] = byte_swap_32 (digest
[1]);
12354 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12356 uint salt_len
= input_len
- 16 - 1;
12358 char *salt_buf
= input_buf
+ 16 + 1;
12360 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12362 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12364 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12366 salt
->salt_len
= salt_len
;
12368 return (PARSER_OK
);
12371 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12373 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12375 u32
*digest
= (u32
*) hash_buf
->digest
;
12377 salt_t
*salt
= hash_buf
->salt
;
12379 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12380 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12381 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12382 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12383 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12385 digest
[0] -= SHA1M_A
;
12386 digest
[1] -= SHA1M_B
;
12387 digest
[2] -= SHA1M_C
;
12388 digest
[3] -= SHA1M_D
;
12389 digest
[4] -= SHA1M_E
;
12391 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12393 uint salt_len
= input_len
- 40 - 1;
12395 char *salt_buf
= input_buf
+ 40 + 1;
12397 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12399 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12401 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12403 salt
->salt_len
= salt_len
;
12405 return (PARSER_OK
);
12408 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12410 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12412 u32
*digest
= (u32
*) hash_buf
->digest
;
12414 salt_t
*salt
= hash_buf
->salt
;
12416 char *hash_pos
= input_buf
;
12418 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12419 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12420 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12421 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12422 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12423 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12424 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12425 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12426 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12427 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12428 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12429 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12430 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12431 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12432 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12433 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12435 char *salt_pos
= input_buf
+ 128;
12437 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12438 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12439 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12440 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12442 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12443 salt
->salt_len
= 16;
12445 return (PARSER_OK
);
12448 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12450 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12452 u32
*digest
= (u32
*) hash_buf
->digest
;
12454 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12455 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12456 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12457 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12458 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12459 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12460 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12461 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12463 digest
[0] -= SHA256M_A
;
12464 digest
[1] -= SHA256M_B
;
12465 digest
[2] -= SHA256M_C
;
12466 digest
[3] -= SHA256M_D
;
12467 digest
[4] -= SHA256M_E
;
12468 digest
[5] -= SHA256M_F
;
12469 digest
[6] -= SHA256M_G
;
12470 digest
[7] -= SHA256M_H
;
12472 return (PARSER_OK
);
12475 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12477 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12479 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12483 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12486 u32
*digest
= (u32
*) hash_buf
->digest
;
12488 salt_t
*salt
= hash_buf
->salt
;
12490 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12491 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12492 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12493 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12494 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12495 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12496 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12497 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12499 digest
[0] -= SHA256M_A
;
12500 digest
[1] -= SHA256M_B
;
12501 digest
[2] -= SHA256M_C
;
12502 digest
[3] -= SHA256M_D
;
12503 digest
[4] -= SHA256M_E
;
12504 digest
[5] -= SHA256M_F
;
12505 digest
[6] -= SHA256M_G
;
12506 digest
[7] -= SHA256M_H
;
12508 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12510 uint salt_len
= input_len
- 64 - 1;
12512 char *salt_buf
= input_buf
+ 64 + 1;
12514 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12516 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12518 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12520 salt
->salt_len
= salt_len
;
12522 return (PARSER_OK
);
12525 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12527 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12529 u64
*digest
= (u64
*) hash_buf
->digest
;
12531 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12532 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12533 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12534 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12535 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12536 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12540 digest
[0] -= SHA384M_A
;
12541 digest
[1] -= SHA384M_B
;
12542 digest
[2] -= SHA384M_C
;
12543 digest
[3] -= SHA384M_D
;
12544 digest
[4] -= SHA384M_E
;
12545 digest
[5] -= SHA384M_F
;
12549 return (PARSER_OK
);
12552 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12554 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12556 u64
*digest
= (u64
*) hash_buf
->digest
;
12558 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12559 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12560 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12561 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12562 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12563 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12564 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12565 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12567 digest
[0] -= SHA512M_A
;
12568 digest
[1] -= SHA512M_B
;
12569 digest
[2] -= SHA512M_C
;
12570 digest
[3] -= SHA512M_D
;
12571 digest
[4] -= SHA512M_E
;
12572 digest
[5] -= SHA512M_F
;
12573 digest
[6] -= SHA512M_G
;
12574 digest
[7] -= SHA512M_H
;
12576 return (PARSER_OK
);
12579 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12581 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12583 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12587 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12590 u64
*digest
= (u64
*) hash_buf
->digest
;
12592 salt_t
*salt
= hash_buf
->salt
;
12594 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12595 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12596 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12597 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12598 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12599 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12600 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12601 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12603 digest
[0] -= SHA512M_A
;
12604 digest
[1] -= SHA512M_B
;
12605 digest
[2] -= SHA512M_C
;
12606 digest
[3] -= SHA512M_D
;
12607 digest
[4] -= SHA512M_E
;
12608 digest
[5] -= SHA512M_F
;
12609 digest
[6] -= SHA512M_G
;
12610 digest
[7] -= SHA512M_H
;
12612 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12614 uint salt_len
= input_len
- 128 - 1;
12616 char *salt_buf
= input_buf
+ 128 + 1;
12618 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12620 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12622 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12624 salt
->salt_len
= salt_len
;
12626 return (PARSER_OK
);
12629 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12631 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12633 u64
*digest
= (u64
*) hash_buf
->digest
;
12635 salt_t
*salt
= hash_buf
->salt
;
12637 char *salt_pos
= input_buf
+ 3;
12639 uint iterations_len
= 0;
12641 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12645 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12647 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12648 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12652 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12656 iterations_len
+= 8;
12660 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12663 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12665 char *hash_pos
= strchr (salt_pos
, '$');
12667 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12669 uint salt_len
= hash_pos
- salt_pos
;
12671 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12673 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12675 salt
->salt_len
= salt_len
;
12679 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12681 return (PARSER_OK
);
12684 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12686 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12688 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12690 u64
*digest
= (u64
*) hash_buf
->digest
;
12692 salt_t
*salt
= hash_buf
->salt
;
12694 uint keccak_mdlen
= input_len
/ 2;
12696 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12698 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12700 digest
[i
] = byte_swap_64 (digest
[i
]);
12703 salt
->keccak_mdlen
= keccak_mdlen
;
12705 return (PARSER_OK
);
12708 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12710 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12712 u32
*digest
= (u32
*) hash_buf
->digest
;
12714 salt_t
*salt
= hash_buf
->salt
;
12716 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12719 * Parse that strange long line
12724 size_t in_len
[9] = { 0 };
12726 in_off
[0] = strtok (input_buf
, ":");
12728 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12730 in_len
[0] = strlen (in_off
[0]);
12734 for (i
= 1; i
< 9; i
++)
12736 in_off
[i
] = strtok (NULL
, ":");
12738 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12740 in_len
[i
] = strlen (in_off
[i
]);
12743 char *ptr
= (char *) ikepsk
->msg_buf
;
12745 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12746 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12747 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12748 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12749 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12750 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12754 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12756 ptr
= (char *) ikepsk
->nr_buf
;
12758 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12759 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12763 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12766 * Store to database
12771 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12772 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12773 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12774 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12776 digest
[0] = byte_swap_32 (digest
[0]);
12777 digest
[1] = byte_swap_32 (digest
[1]);
12778 digest
[2] = byte_swap_32 (digest
[2]);
12779 digest
[3] = byte_swap_32 (digest
[3]);
12781 salt
->salt_len
= 32;
12783 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12784 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12785 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12786 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12787 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12788 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12789 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12790 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12792 return (PARSER_OK
);
12795 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12797 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12799 u32
*digest
= (u32
*) hash_buf
->digest
;
12801 salt_t
*salt
= hash_buf
->salt
;
12803 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12806 * Parse that strange long line
12811 size_t in_len
[9] = { 0 };
12813 in_off
[0] = strtok (input_buf
, ":");
12815 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12817 in_len
[0] = strlen (in_off
[0]);
12821 for (i
= 1; i
< 9; i
++)
12823 in_off
[i
] = strtok (NULL
, ":");
12825 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12827 in_len
[i
] = strlen (in_off
[i
]);
12830 char *ptr
= (char *) ikepsk
->msg_buf
;
12832 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12833 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12834 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12835 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12836 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12837 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12841 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12843 ptr
= (char *) ikepsk
->nr_buf
;
12845 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12846 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12850 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12853 * Store to database
12858 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12859 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12860 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12861 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12862 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12864 salt
->salt_len
= 32;
12866 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12867 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12868 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12869 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12870 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12871 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12872 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12873 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12875 return (PARSER_OK
);
12878 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12880 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12882 u32
*digest
= (u32
*) hash_buf
->digest
;
12884 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12885 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12886 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12887 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12888 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12890 digest
[0] = byte_swap_32 (digest
[0]);
12891 digest
[1] = byte_swap_32 (digest
[1]);
12892 digest
[2] = byte_swap_32 (digest
[2]);
12893 digest
[3] = byte_swap_32 (digest
[3]);
12894 digest
[4] = byte_swap_32 (digest
[4]);
12896 return (PARSER_OK
);
12899 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12901 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12903 u32
*digest
= (u32
*) hash_buf
->digest
;
12905 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12906 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12907 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12908 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12909 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12910 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12911 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12912 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12913 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12914 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12915 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12916 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12917 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12918 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12919 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12920 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12922 return (PARSER_OK
);
12925 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12927 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12929 u32
*digest
= (u32
*) hash_buf
->digest
;
12931 salt_t
*salt
= hash_buf
->salt
;
12933 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12934 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12935 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12936 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12937 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12939 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12941 uint salt_len
= input_len
- 40 - 1;
12943 char *salt_buf
= input_buf
+ 40 + 1;
12945 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12947 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12949 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12951 salt
->salt_len
= salt_len
;
12953 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12955 return (PARSER_OK
);
12958 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12960 u32
*digest
= (u32
*) hash_buf
->digest
;
12962 salt_t
*salt
= hash_buf
->salt
;
12964 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12966 if (input_len
== 0)
12968 log_error ("TrueCrypt container not specified");
12973 FILE *fp
= fopen (input_buf
, "rb");
12977 log_error ("%s: %s", input_buf
, strerror (errno
));
12982 char buf
[512] = { 0 };
12984 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12988 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12990 memcpy (tc
->salt_buf
, buf
, 64);
12992 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12994 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12996 salt
->salt_len
= 4;
12998 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13000 tc
->signature
= 0x45555254; // "TRUE"
13002 digest
[0] = tc
->data_buf
[0];
13004 return (PARSER_OK
);
13007 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13009 u32
*digest
= (u32
*) hash_buf
->digest
;
13011 salt_t
*salt
= hash_buf
->salt
;
13013 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13015 if (input_len
== 0)
13017 log_error ("TrueCrypt container not specified");
13022 FILE *fp
= fopen (input_buf
, "rb");
13026 log_error ("%s: %s", input_buf
, strerror (errno
));
13031 char buf
[512] = { 0 };
13033 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13037 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13039 memcpy (tc
->salt_buf
, buf
, 64);
13041 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13043 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13045 salt
->salt_len
= 4;
13047 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13049 tc
->signature
= 0x45555254; // "TRUE"
13051 digest
[0] = tc
->data_buf
[0];
13053 return (PARSER_OK
);
13056 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13058 u32
*digest
= (u32
*) hash_buf
->digest
;
13060 salt_t
*salt
= hash_buf
->salt
;
13062 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13064 if (input_len
== 0)
13066 log_error ("VeraCrypt container not specified");
13071 FILE *fp
= fopen (input_buf
, "rb");
13075 log_error ("%s: %s", input_buf
, strerror (errno
));
13080 char buf
[512] = { 0 };
13082 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13086 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13088 memcpy (tc
->salt_buf
, buf
, 64);
13090 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13092 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13094 salt
->salt_len
= 4;
13096 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13098 tc
->signature
= 0x41524556; // "VERA"
13100 digest
[0] = tc
->data_buf
[0];
13102 return (PARSER_OK
);
13105 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13107 u32
*digest
= (u32
*) hash_buf
->digest
;
13109 salt_t
*salt
= hash_buf
->salt
;
13111 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13113 if (input_len
== 0)
13115 log_error ("VeraCrypt container not specified");
13120 FILE *fp
= fopen (input_buf
, "rb");
13124 log_error ("%s: %s", input_buf
, strerror (errno
));
13129 char buf
[512] = { 0 };
13131 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13135 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13137 memcpy (tc
->salt_buf
, buf
, 64);
13139 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13141 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13143 salt
->salt_len
= 4;
13145 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13147 tc
->signature
= 0x41524556; // "VERA"
13149 digest
[0] = tc
->data_buf
[0];
13151 return (PARSER_OK
);
13154 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13156 u32
*digest
= (u32
*) hash_buf
->digest
;
13158 salt_t
*salt
= hash_buf
->salt
;
13160 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13162 if (input_len
== 0)
13164 log_error ("VeraCrypt container not specified");
13169 FILE *fp
= fopen (input_buf
, "rb");
13173 log_error ("%s: %s", input_buf
, strerror (errno
));
13178 char buf
[512] = { 0 };
13180 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13184 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13186 memcpy (tc
->salt_buf
, buf
, 64);
13188 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13190 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13192 salt
->salt_len
= 4;
13194 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13196 tc
->signature
= 0x41524556; // "VERA"
13198 digest
[0] = tc
->data_buf
[0];
13200 return (PARSER_OK
);
13203 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13205 u32
*digest
= (u32
*) hash_buf
->digest
;
13207 salt_t
*salt
= hash_buf
->salt
;
13209 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13211 if (input_len
== 0)
13213 log_error ("VeraCrypt container not specified");
13218 FILE *fp
= fopen (input_buf
, "rb");
13222 log_error ("%s: %s", input_buf
, strerror (errno
));
13227 char buf
[512] = { 0 };
13229 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13233 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13235 memcpy (tc
->salt_buf
, buf
, 64);
13237 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13239 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13241 salt
->salt_len
= 4;
13243 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13245 tc
->signature
= 0x41524556; // "VERA"
13247 digest
[0] = tc
->data_buf
[0];
13249 return (PARSER_OK
);
13252 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13254 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13256 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13258 u32
*digest
= (u32
*) hash_buf
->digest
;
13260 salt_t
*salt
= hash_buf
->salt
;
13262 char *salt_pos
= input_buf
+ 6;
13264 char *hash_pos
= strchr (salt_pos
, '$');
13266 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13268 uint salt_len
= hash_pos
- salt_pos
;
13270 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13272 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13274 salt
->salt_len
= salt_len
;
13276 salt
->salt_iter
= 1000;
13280 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13282 return (PARSER_OK
);
13285 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13287 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13289 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13291 u32
*digest
= (u32
*) hash_buf
->digest
;
13293 salt_t
*salt
= hash_buf
->salt
;
13295 char *iter_pos
= input_buf
+ 7;
13297 char *salt_pos
= strchr (iter_pos
, '$');
13299 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13303 char *hash_pos
= strchr (salt_pos
, '$');
13305 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13307 uint salt_len
= hash_pos
- salt_pos
;
13309 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13311 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13313 salt
->salt_len
= salt_len
;
13315 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13317 salt
->salt_sign
[0] = atoi (salt_iter
);
13319 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13323 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13325 digest
[0] = byte_swap_32 (digest
[0]);
13326 digest
[1] = byte_swap_32 (digest
[1]);
13327 digest
[2] = byte_swap_32 (digest
[2]);
13328 digest
[3] = byte_swap_32 (digest
[3]);
13329 digest
[4] = byte_swap_32 (digest
[4]);
13331 return (PARSER_OK
);
13334 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13336 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13338 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13340 u32
*digest
= (u32
*) hash_buf
->digest
;
13342 salt_t
*salt
= hash_buf
->salt
;
13344 char *iter_pos
= input_buf
+ 9;
13346 char *salt_pos
= strchr (iter_pos
, '$');
13348 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13352 char *hash_pos
= strchr (salt_pos
, '$');
13354 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13356 uint salt_len
= hash_pos
- salt_pos
;
13358 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13360 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13362 salt
->salt_len
= salt_len
;
13364 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13366 salt
->salt_sign
[0] = atoi (salt_iter
);
13368 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13372 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13374 digest
[0] = byte_swap_32 (digest
[0]);
13375 digest
[1] = byte_swap_32 (digest
[1]);
13376 digest
[2] = byte_swap_32 (digest
[2]);
13377 digest
[3] = byte_swap_32 (digest
[3]);
13378 digest
[4] = byte_swap_32 (digest
[4]);
13379 digest
[5] = byte_swap_32 (digest
[5]);
13380 digest
[6] = byte_swap_32 (digest
[6]);
13381 digest
[7] = byte_swap_32 (digest
[7]);
13383 return (PARSER_OK
);
13386 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13388 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13390 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13392 u64
*digest
= (u64
*) hash_buf
->digest
;
13394 salt_t
*salt
= hash_buf
->salt
;
13396 char *iter_pos
= input_buf
+ 9;
13398 char *salt_pos
= strchr (iter_pos
, '$');
13400 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13404 char *hash_pos
= strchr (salt_pos
, '$');
13406 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13408 uint salt_len
= hash_pos
- salt_pos
;
13410 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13412 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13414 salt
->salt_len
= salt_len
;
13416 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13418 salt
->salt_sign
[0] = atoi (salt_iter
);
13420 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13424 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13426 digest
[0] = byte_swap_64 (digest
[0]);
13427 digest
[1] = byte_swap_64 (digest
[1]);
13428 digest
[2] = byte_swap_64 (digest
[2]);
13429 digest
[3] = byte_swap_64 (digest
[3]);
13430 digest
[4] = byte_swap_64 (digest
[4]);
13431 digest
[5] = byte_swap_64 (digest
[5]);
13432 digest
[6] = byte_swap_64 (digest
[6]);
13433 digest
[7] = byte_swap_64 (digest
[7]);
13435 return (PARSER_OK
);
13438 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13440 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13442 u32
*digest
= (u32
*) hash_buf
->digest
;
13444 salt_t
*salt
= hash_buf
->salt
;
13446 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13452 char *iterations_pos
= input_buf
;
13454 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13456 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13458 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13460 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13464 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13466 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13468 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13470 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13472 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13474 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13479 * pbkdf2 iterations
13482 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13485 * handle salt encoding
13488 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13490 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13492 const char p0
= saltbuf_pos
[i
+ 0];
13493 const char p1
= saltbuf_pos
[i
+ 1];
13495 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13496 | hex_convert (p0
) << 4;
13499 salt
->salt_len
= saltbuf_len
/ 2;
13502 * handle cipher encoding
13505 uint
*tmp
= (uint
*) mymalloc (32);
13507 char *cipherbuf_ptr
= (char *) tmp
;
13509 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13511 const char p0
= cipherbuf_pos
[i
+ 0];
13512 const char p1
= cipherbuf_pos
[i
+ 1];
13514 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13515 | hex_convert (p0
) << 4;
13518 // iv is stored at salt_buf 4 (length 16)
13519 // data is stored at salt_buf 8 (length 16)
13521 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13522 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13523 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13524 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13526 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13527 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13528 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13529 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13533 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13535 const char p0
= cipherbuf_pos
[j
+ 0];
13536 const char p1
= cipherbuf_pos
[j
+ 1];
13538 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13539 | hex_convert (p0
) << 4;
13546 digest
[0] = 0x10101010;
13547 digest
[1] = 0x10101010;
13548 digest
[2] = 0x10101010;
13549 digest
[3] = 0x10101010;
13551 return (PARSER_OK
);
13554 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13556 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13558 u32
*digest
= (u32
*) hash_buf
->digest
;
13560 salt_t
*salt
= hash_buf
->salt
;
13562 char *hashbuf_pos
= input_buf
;
13564 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13566 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13568 uint hash_len
= iterations_pos
- hashbuf_pos
;
13570 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13574 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13576 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13578 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13582 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13584 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13586 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13588 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13590 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13592 salt
->salt_len
= salt_len
;
13594 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13596 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13597 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13598 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13599 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13601 return (PARSER_OK
);
13604 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13606 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13608 u32
*digest
= (u32
*) hash_buf
->digest
;
13610 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13611 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13612 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13613 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13614 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13615 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13616 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13617 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13619 digest
[0] = byte_swap_32 (digest
[0]);
13620 digest
[1] = byte_swap_32 (digest
[1]);
13621 digest
[2] = byte_swap_32 (digest
[2]);
13622 digest
[3] = byte_swap_32 (digest
[3]);
13623 digest
[4] = byte_swap_32 (digest
[4]);
13624 digest
[5] = byte_swap_32 (digest
[5]);
13625 digest
[6] = byte_swap_32 (digest
[6]);
13626 digest
[7] = byte_swap_32 (digest
[7]);
13628 return (PARSER_OK
);
13631 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13633 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13635 u32
*digest
= (u32
*) hash_buf
->digest
;
13637 salt_t
*salt
= hash_buf
->salt
;
13639 char *salt_pos
= input_buf
+ 3;
13641 uint iterations_len
= 0;
13643 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13647 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13649 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13650 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13654 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13658 iterations_len
+= 8;
13662 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13665 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13667 char *hash_pos
= strchr (salt_pos
, '$');
13669 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13671 uint salt_len
= hash_pos
- salt_pos
;
13673 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13675 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13677 salt
->salt_len
= salt_len
;
13681 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13683 return (PARSER_OK
);
13686 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13688 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13690 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13692 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13694 u64
*digest
= (u64
*) hash_buf
->digest
;
13696 salt_t
*salt
= hash_buf
->salt
;
13698 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13700 char *iter_pos
= input_buf
+ 4;
13702 char *salt_pos
= strchr (iter_pos
, '$');
13704 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13708 char *hash_pos
= strchr (salt_pos
, '$');
13710 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13712 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13716 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13717 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13718 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13719 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13720 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13721 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13722 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13723 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13725 uint salt_len
= hash_pos
- salt_pos
- 1;
13727 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13729 salt
->salt_len
= salt_len
/ 2;
13731 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13732 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13733 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13734 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13735 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13736 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13737 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13738 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13740 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13741 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13742 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13743 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13744 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13745 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13746 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13747 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13748 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13749 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13751 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13753 salt
->salt_iter
= atoi (iter_pos
) - 1;
13755 return (PARSER_OK
);
13758 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13760 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13762 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13764 u32
*digest
= (u32
*) hash_buf
->digest
;
13766 salt_t
*salt
= hash_buf
->salt
;
13768 char *salt_pos
= input_buf
+ 14;
13770 char *hash_pos
= strchr (salt_pos
, '*');
13772 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13776 uint salt_len
= hash_pos
- salt_pos
- 1;
13778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13780 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13782 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13784 salt
->salt_len
= salt_len
;
13786 u8 tmp_buf
[100] = { 0 };
13788 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13790 memcpy (digest
, tmp_buf
, 32);
13792 digest
[0] = byte_swap_32 (digest
[0]);
13793 digest
[1] = byte_swap_32 (digest
[1]);
13794 digest
[2] = byte_swap_32 (digest
[2]);
13795 digest
[3] = byte_swap_32 (digest
[3]);
13796 digest
[4] = byte_swap_32 (digest
[4]);
13797 digest
[5] = byte_swap_32 (digest
[5]);
13798 digest
[6] = byte_swap_32 (digest
[6]);
13799 digest
[7] = byte_swap_32 (digest
[7]);
13801 digest
[0] -= SHA256M_A
;
13802 digest
[1] -= SHA256M_B
;
13803 digest
[2] -= SHA256M_C
;
13804 digest
[3] -= SHA256M_D
;
13805 digest
[4] -= SHA256M_E
;
13806 digest
[5] -= SHA256M_F
;
13807 digest
[6] -= SHA256M_G
;
13808 digest
[7] -= SHA256M_H
;
13810 return (PARSER_OK
);
13813 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13815 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13817 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13819 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13821 u64
*digest
= (u64
*) hash_buf
->digest
;
13823 salt_t
*salt
= hash_buf
->salt
;
13825 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13827 char *iter_pos
= input_buf
+ 19;
13829 char *salt_pos
= strchr (iter_pos
, '.');
13831 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13835 char *hash_pos
= strchr (salt_pos
, '.');
13837 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13839 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13843 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13844 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13845 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13846 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13847 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13848 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13849 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13850 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13852 uint salt_len
= hash_pos
- salt_pos
- 1;
13856 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13860 for (i
= 0; i
< salt_len
; i
++)
13862 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13865 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13866 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13868 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13870 salt
->salt_len
= salt_len
;
13872 salt
->salt_iter
= atoi (iter_pos
) - 1;
13874 return (PARSER_OK
);
13877 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13879 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13881 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13883 u64
*digest
= (u64
*) hash_buf
->digest
;
13885 salt_t
*salt
= hash_buf
->salt
;
13887 u8 tmp_buf
[120] = { 0 };
13889 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13891 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13893 memcpy (digest
, tmp_buf
, 64);
13895 digest
[0] = byte_swap_64 (digest
[0]);
13896 digest
[1] = byte_swap_64 (digest
[1]);
13897 digest
[2] = byte_swap_64 (digest
[2]);
13898 digest
[3] = byte_swap_64 (digest
[3]);
13899 digest
[4] = byte_swap_64 (digest
[4]);
13900 digest
[5] = byte_swap_64 (digest
[5]);
13901 digest
[6] = byte_swap_64 (digest
[6]);
13902 digest
[7] = byte_swap_64 (digest
[7]);
13904 digest
[0] -= SHA512M_A
;
13905 digest
[1] -= SHA512M_B
;
13906 digest
[2] -= SHA512M_C
;
13907 digest
[3] -= SHA512M_D
;
13908 digest
[4] -= SHA512M_E
;
13909 digest
[5] -= SHA512M_F
;
13910 digest
[6] -= SHA512M_G
;
13911 digest
[7] -= SHA512M_H
;
13913 int salt_len
= tmp_len
- 64;
13915 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13917 salt
->salt_len
= salt_len
;
13919 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13921 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13923 char *ptr
= (char *) salt
->salt_buf
;
13925 ptr
[salt
->salt_len
] = 0x80;
13928 return (PARSER_OK
);
13931 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13933 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13935 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13939 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13942 u32
*digest
= (u32
*) hash_buf
->digest
;
13944 salt_t
*salt
= hash_buf
->salt
;
13946 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13947 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13948 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13949 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13951 digest
[0] = byte_swap_32 (digest
[0]);
13952 digest
[1] = byte_swap_32 (digest
[1]);
13953 digest
[2] = byte_swap_32 (digest
[2]);
13954 digest
[3] = byte_swap_32 (digest
[3]);
13956 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13958 uint salt_len
= input_len
- 32 - 1;
13960 char *salt_buf
= input_buf
+ 32 + 1;
13962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13968 salt
->salt_len
= salt_len
;
13970 return (PARSER_OK
);
13973 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13975 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13977 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13981 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13984 u32
*digest
= (u32
*) hash_buf
->digest
;
13986 salt_t
*salt
= hash_buf
->salt
;
13988 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13989 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13990 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13991 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13992 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13994 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13996 uint salt_len
= input_len
- 40 - 1;
13998 char *salt_buf
= input_buf
+ 40 + 1;
14000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14006 salt
->salt_len
= salt_len
;
14008 return (PARSER_OK
);
14011 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14013 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14015 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14019 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14022 u32
*digest
= (u32
*) hash_buf
->digest
;
14024 salt_t
*salt
= hash_buf
->salt
;
14026 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14027 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14028 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14029 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14030 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14031 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14032 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14033 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14035 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14037 uint salt_len
= input_len
- 64 - 1;
14039 char *salt_buf
= input_buf
+ 64 + 1;
14041 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14043 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14045 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14047 salt
->salt_len
= salt_len
;
14049 return (PARSER_OK
);
14052 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14054 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14056 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14060 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14063 u64
*digest
= (u64
*) hash_buf
->digest
;
14065 salt_t
*salt
= hash_buf
->salt
;
14067 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14068 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14069 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14070 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14071 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14072 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14073 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14074 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14076 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14078 uint salt_len
= input_len
- 128 - 1;
14080 char *salt_buf
= input_buf
+ 128 + 1;
14082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14088 salt
->salt_len
= salt_len
;
14090 return (PARSER_OK
);
14093 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14095 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14097 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14099 u32
*digest
= (u32
*) hash_buf
->digest
;
14101 salt_t
*salt
= hash_buf
->salt
;
14103 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14109 char *user_pos
= input_buf
+ 10 + 1;
14111 char *realm_pos
= strchr (user_pos
, '$');
14113 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14115 uint user_len
= realm_pos
- user_pos
;
14117 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14121 char *salt_pos
= strchr (realm_pos
, '$');
14123 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14125 uint realm_len
= salt_pos
- realm_pos
;
14127 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14131 char *data_pos
= strchr (salt_pos
, '$');
14133 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14135 uint salt_len
= data_pos
- salt_pos
;
14137 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14141 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14143 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14149 memcpy (krb5pa
->user
, user_pos
, user_len
);
14150 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14151 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14153 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14155 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14157 const char p0
= data_pos
[i
+ 0];
14158 const char p1
= data_pos
[i
+ 1];
14160 *timestamp_ptr
++ = hex_convert (p1
) << 0
14161 | hex_convert (p0
) << 4;
14164 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14166 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14168 const char p0
= data_pos
[i
+ 0];
14169 const char p1
= data_pos
[i
+ 1];
14171 *checksum_ptr
++ = hex_convert (p1
) << 0
14172 | hex_convert (p0
) << 4;
14176 * copy some data to generic buffers to make sorting happy
14179 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14180 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14181 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14182 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14183 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14184 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14185 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14186 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14187 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14189 salt
->salt_len
= 36;
14191 digest
[0] = krb5pa
->checksum
[0];
14192 digest
[1] = krb5pa
->checksum
[1];
14193 digest
[2] = krb5pa
->checksum
[2];
14194 digest
[3] = krb5pa
->checksum
[3];
14196 return (PARSER_OK
);
14199 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14201 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14203 u32
*digest
= (u32
*) hash_buf
->digest
;
14205 salt_t
*salt
= hash_buf
->salt
;
14211 char *salt_pos
= input_buf
;
14213 char *hash_pos
= strchr (salt_pos
, '$');
14215 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14217 uint salt_len
= hash_pos
- salt_pos
;
14219 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14223 uint hash_len
= input_len
- 1 - salt_len
;
14225 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14233 for (uint i
= 0; i
< salt_len
; i
++)
14235 if (salt_pos
[i
] == ' ') continue;
14240 // SAP user names cannot be longer than 12 characters
14241 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14243 // SAP user name cannot start with ! or ?
14244 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14256 salt
->salt_len
= salt_len
;
14258 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14259 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14263 digest
[0] = byte_swap_32 (digest
[0]);
14264 digest
[1] = byte_swap_32 (digest
[1]);
14266 return (PARSER_OK
);
14269 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14271 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14273 u32
*digest
= (u32
*) hash_buf
->digest
;
14275 salt_t
*salt
= hash_buf
->salt
;
14281 char *salt_pos
= input_buf
;
14283 char *hash_pos
= strchr (salt_pos
, '$');
14285 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14287 uint salt_len
= hash_pos
- salt_pos
;
14289 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14293 uint hash_len
= input_len
- 1 - salt_len
;
14295 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14303 for (uint i
= 0; i
< salt_len
; i
++)
14305 if (salt_pos
[i
] == ' ') continue;
14310 // SAP user names cannot be longer than 12 characters
14311 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14312 // so far nobody complained so we stay with this because it helps in optimization
14313 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14315 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14317 // SAP user name cannot start with ! or ?
14318 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14328 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14330 salt
->salt_len
= salt_len
;
14332 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14333 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14334 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14335 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14336 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14338 return (PARSER_OK
);
14341 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14343 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14345 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14347 u64
*digest
= (u64
*) hash_buf
->digest
;
14349 salt_t
*salt
= hash_buf
->salt
;
14351 char *iter_pos
= input_buf
+ 3;
14353 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14355 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14357 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14359 salt
->salt_iter
= salt_iter
;
14361 char *salt_pos
= iter_pos
+ 1;
14365 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14367 salt
->salt_len
= salt_len
;
14369 char *hash_pos
= salt_pos
+ salt_len
;
14371 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14375 char *tmp
= (char *) salt
->salt_buf_pc
;
14377 tmp
[0] = hash_pos
[42];
14381 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14382 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14383 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14384 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14390 return (PARSER_OK
);
14393 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14395 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14397 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14399 u32
*digest
= (u32
*) hash_buf
->digest
;
14401 salt_t
*salt
= hash_buf
->salt
;
14403 char *salt_buf
= input_buf
+ 6;
14405 uint salt_len
= 16;
14407 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14409 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14411 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14413 salt
->salt_len
= salt_len
;
14415 char *hash_pos
= input_buf
+ 6 + 16;
14417 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14418 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14419 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14420 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14421 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14422 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14423 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14424 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14426 return (PARSER_OK
);
14429 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14431 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14433 u32
*digest
= (u32
*) hash_buf
->digest
;
14435 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14436 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14440 return (PARSER_OK
);
14443 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14445 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14447 u32
*digest
= (u32
*) hash_buf
->digest
;
14449 salt_t
*salt
= hash_buf
->salt
;
14451 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14453 char *saltbuf_pos
= input_buf
;
14455 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14457 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14459 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14461 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14462 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14464 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14468 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14470 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14472 char *salt_ptr
= (char *) saltbuf_pos
;
14473 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14478 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14480 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14483 rakp_ptr
[j
] = 0x80;
14485 rakp
->salt_len
= j
;
14487 for (i
= 0; i
< 64; i
++)
14489 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14492 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14493 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14494 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14495 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14496 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14497 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14498 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14499 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14501 salt
->salt_len
= 32; // muss min. 32 haben
14503 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14504 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14505 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14506 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14507 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14509 return (PARSER_OK
);
14512 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14514 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14516 u32
*digest
= (u32
*) hash_buf
->digest
;
14518 salt_t
*salt
= hash_buf
->salt
;
14520 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14522 char *salt_pos
= input_buf
+ 1;
14524 memcpy (salt
->salt_buf
, salt_pos
, 8);
14526 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14527 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14529 salt
->salt_len
= 8;
14531 char *hash_pos
= salt_pos
+ 8;
14533 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14534 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14535 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14536 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14537 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14539 digest
[0] -= SHA1M_A
;
14540 digest
[1] -= SHA1M_B
;
14541 digest
[2] -= SHA1M_C
;
14542 digest
[3] -= SHA1M_D
;
14543 digest
[4] -= SHA1M_E
;
14545 return (PARSER_OK
);
14548 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14550 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14552 u32
*digest
= (u32
*) hash_buf
->digest
;
14554 salt_t
*salt
= hash_buf
->salt
;
14556 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14557 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14558 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14559 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14561 digest
[0] = byte_swap_32 (digest
[0]);
14562 digest
[1] = byte_swap_32 (digest
[1]);
14563 digest
[2] = byte_swap_32 (digest
[2]);
14564 digest
[3] = byte_swap_32 (digest
[3]);
14566 digest
[0] -= MD5M_A
;
14567 digest
[1] -= MD5M_B
;
14568 digest
[2] -= MD5M_C
;
14569 digest
[3] -= MD5M_D
;
14571 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14573 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14575 u32
*salt_buf
= salt
->salt_buf
;
14577 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14578 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14579 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14580 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14582 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14583 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14584 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14585 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14587 salt
->salt_len
= 16 + 1;
14589 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14591 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14593 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14595 return (PARSER_OK
);
14598 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14600 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14602 u32
*digest
= (u32
*) hash_buf
->digest
;
14604 salt_t
*salt
= hash_buf
->salt
;
14606 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14612 char *hashbuf_pos
= input_buf
;
14614 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14616 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14618 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14620 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14624 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14626 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14628 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14630 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14634 char *databuf_pos
= strchr (iteration_pos
, ':');
14636 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14638 const uint iteration_len
= databuf_pos
- iteration_pos
;
14640 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14641 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14643 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14645 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14646 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14652 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14653 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14654 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14655 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14656 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14657 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14658 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14659 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14663 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14665 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14667 const char p0
= saltbuf_pos
[i
+ 0];
14668 const char p1
= saltbuf_pos
[i
+ 1];
14670 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14671 | hex_convert (p0
) << 4;
14674 salt
->salt_buf
[4] = 0x01000000;
14675 salt
->salt_buf
[5] = 0x80;
14677 salt
->salt_len
= saltbuf_len
/ 2;
14681 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14685 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14687 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14689 const char p0
= databuf_pos
[i
+ 0];
14690 const char p1
= databuf_pos
[i
+ 1];
14692 *databuf_ptr
++ = hex_convert (p1
) << 0
14693 | hex_convert (p0
) << 4;
14696 *databuf_ptr
++ = 0x80;
14698 for (uint i
= 0; i
< 512; i
++)
14700 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14703 cloudkey
->data_len
= databuf_len
/ 2;
14705 return (PARSER_OK
);
14708 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14710 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14712 u32
*digest
= (u32
*) hash_buf
->digest
;
14714 salt_t
*salt
= hash_buf
->salt
;
14720 char *hashbuf_pos
= input_buf
;
14722 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14724 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14726 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14728 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14732 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14734 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14736 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14738 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14740 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14744 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14746 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14748 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14750 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14752 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14756 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14758 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14759 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14761 // ok, the plan for this algorithm is the following:
14762 // we have 2 salts here, the domain-name and a random salt
14763 // while both are used in the initial transformation,
14764 // only the random salt is used in the following iterations
14765 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14766 // and one that includes only the real salt (stored into salt_buf[]).
14767 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14769 u8 tmp_buf
[100] = { 0 };
14771 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14773 memcpy (digest
, tmp_buf
, 20);
14775 digest
[0] = byte_swap_32 (digest
[0]);
14776 digest
[1] = byte_swap_32 (digest
[1]);
14777 digest
[2] = byte_swap_32 (digest
[2]);
14778 digest
[3] = byte_swap_32 (digest
[3]);
14779 digest
[4] = byte_swap_32 (digest
[4]);
14783 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14785 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14787 char *len_ptr
= NULL
;
14789 for (uint i
= 0; i
< domainbuf_len
; i
++)
14791 if (salt_buf_pc_ptr
[i
] == '.')
14793 len_ptr
= &salt_buf_pc_ptr
[i
];
14803 salt
->salt_buf_pc
[7] = domainbuf_len
;
14807 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14809 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14811 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14813 salt
->salt_len
= salt_len
;
14817 salt
->salt_iter
= atoi (iteration_pos
);
14819 return (PARSER_OK
);
14822 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14824 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14826 u32
*digest
= (u32
*) hash_buf
->digest
;
14828 salt_t
*salt
= hash_buf
->salt
;
14830 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14831 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14832 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14833 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14834 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14836 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14838 uint salt_len
= input_len
- 40 - 1;
14840 char *salt_buf
= input_buf
+ 40 + 1;
14842 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14844 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14846 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14848 salt
->salt_len
= salt_len
;
14850 return (PARSER_OK
);
14853 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14855 const u8 ascii_to_ebcdic
[] =
14857 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14858 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14859 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14860 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14861 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14862 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14863 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14864 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14865 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14866 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14867 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14868 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14869 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14870 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14871 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14872 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14875 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14877 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14879 u32
*digest
= (u32
*) hash_buf
->digest
;
14881 salt_t
*salt
= hash_buf
->salt
;
14883 char *salt_pos
= input_buf
+ 6 + 1;
14885 char *digest_pos
= strchr (salt_pos
, '*');
14887 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14889 uint salt_len
= digest_pos
- salt_pos
;
14891 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14893 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14895 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14899 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14900 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14902 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14904 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14906 salt
->salt_len
= salt_len
;
14908 for (uint i
= 0; i
< salt_len
; i
++)
14910 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14912 for (uint i
= salt_len
; i
< 8; i
++)
14914 salt_buf_pc_ptr
[i
] = 0x40;
14919 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14921 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14922 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14924 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14925 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14927 digest
[0] = byte_swap_32 (digest
[0]);
14928 digest
[1] = byte_swap_32 (digest
[1]);
14930 IP (digest
[0], digest
[1], tt
);
14932 digest
[0] = rotr32 (digest
[0], 29);
14933 digest
[1] = rotr32 (digest
[1], 29);
14937 return (PARSER_OK
);
14940 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14942 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14944 u32
*digest
= (u32
*) hash_buf
->digest
;
14946 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14947 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14948 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14949 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14951 digest
[0] = byte_swap_32 (digest
[0]);
14952 digest
[1] = byte_swap_32 (digest
[1]);
14953 digest
[2] = byte_swap_32 (digest
[2]);
14954 digest
[3] = byte_swap_32 (digest
[3]);
14956 return (PARSER_OK
);
14959 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14961 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14963 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14965 u32
*digest
= (u32
*) hash_buf
->digest
;
14967 salt_t
*salt
= hash_buf
->salt
;
14969 u8 tmp_buf
[120] = { 0 };
14971 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14973 tmp_buf
[3] += -4; // dont ask!
14975 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14977 salt
->salt_len
= 5;
14979 memcpy (digest
, tmp_buf
+ 5, 9);
14981 // yes, only 9 byte are needed to crack, but 10 to display
14983 salt
->salt_buf_pc
[7] = input_buf
[20];
14985 return (PARSER_OK
);
14988 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14990 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14992 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14994 u32
*digest
= (u32
*) hash_buf
->digest
;
14996 salt_t
*salt
= hash_buf
->salt
;
14998 u8 tmp_buf
[120] = { 0 };
15000 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15002 tmp_buf
[3] += -4; // dont ask!
15006 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15008 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)
15012 char tmp_iter_buf
[11] = { 0 };
15014 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15016 tmp_iter_buf
[10] = 0;
15018 salt
->salt_iter
= atoi (tmp_iter_buf
);
15020 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15022 return (PARSER_SALT_ITERATION
);
15025 salt
->salt_iter
--; // first round in init
15027 // 2 additional bytes for display only
15029 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15030 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15034 memcpy (digest
, tmp_buf
+ 28, 8);
15036 digest
[0] = byte_swap_32 (digest
[0]);
15037 digest
[1] = byte_swap_32 (digest
[1]);
15041 return (PARSER_OK
);
15044 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15046 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15048 u32
*digest
= (u32
*) hash_buf
->digest
;
15050 salt_t
*salt
= hash_buf
->salt
;
15052 char *salt_buf_pos
= input_buf
;
15054 char *hash_buf_pos
= salt_buf_pos
+ 6;
15056 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15057 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15058 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15059 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15060 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15061 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15062 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15063 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15065 digest
[0] -= SHA256M_A
;
15066 digest
[1] -= SHA256M_B
;
15067 digest
[2] -= SHA256M_C
;
15068 digest
[3] -= SHA256M_D
;
15069 digest
[4] -= SHA256M_E
;
15070 digest
[5] -= SHA256M_F
;
15071 digest
[6] -= SHA256M_G
;
15072 digest
[7] -= SHA256M_H
;
15074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15076 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15080 salt
->salt_len
= salt_len
;
15082 return (PARSER_OK
);
15085 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15087 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15089 u32
*digest
= (u32
*) hash_buf
->digest
;
15091 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15093 salt_t
*salt
= hash_buf
->salt
;
15095 char *salt_buf
= input_buf
+ 6;
15097 char *digest_buf
= strchr (salt_buf
, '$');
15099 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15101 uint salt_len
= digest_buf
- salt_buf
;
15103 digest_buf
++; // skip the '$' symbol
15105 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15107 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15109 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15111 salt
->salt_len
= salt_len
;
15113 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15114 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15115 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15116 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15118 digest
[0] = byte_swap_32 (digest
[0]);
15119 digest
[1] = byte_swap_32 (digest
[1]);
15120 digest
[2] = byte_swap_32 (digest
[2]);
15121 digest
[3] = byte_swap_32 (digest
[3]);
15123 digest
[0] -= MD5M_A
;
15124 digest
[1] -= MD5M_B
;
15125 digest
[2] -= MD5M_C
;
15126 digest
[3] -= MD5M_D
;
15128 return (PARSER_OK
);
15131 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15133 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15135 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15137 u32
*digest
= (u32
*) hash_buf
->digest
;
15139 salt_t
*salt
= hash_buf
->salt
;
15141 char *salt_buf
= input_buf
+ 3;
15143 char *digest_buf
= strchr (salt_buf
, '$');
15145 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15147 uint salt_len
= digest_buf
- salt_buf
;
15149 digest_buf
++; // skip the '$' symbol
15151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15153 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15155 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15157 salt_buf_ptr
[salt_len
] = 0x2d;
15159 salt
->salt_len
= salt_len
+ 1;
15161 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15162 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15163 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15164 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15166 digest
[0] = byte_swap_32 (digest
[0]);
15167 digest
[1] = byte_swap_32 (digest
[1]);
15168 digest
[2] = byte_swap_32 (digest
[2]);
15169 digest
[3] = byte_swap_32 (digest
[3]);
15171 digest
[0] -= MD5M_A
;
15172 digest
[1] -= MD5M_B
;
15173 digest
[2] -= MD5M_C
;
15174 digest
[3] -= MD5M_D
;
15176 return (PARSER_OK
);
15179 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15181 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15183 u32
*digest
= (u32
*) hash_buf
->digest
;
15185 salt_t
*salt
= hash_buf
->salt
;
15187 u8 tmp_buf
[100] = { 0 };
15189 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15191 memcpy (digest
, tmp_buf
, 20);
15193 digest
[0] = byte_swap_32 (digest
[0]);
15194 digest
[1] = byte_swap_32 (digest
[1]);
15195 digest
[2] = byte_swap_32 (digest
[2]);
15196 digest
[3] = byte_swap_32 (digest
[3]);
15197 digest
[4] = byte_swap_32 (digest
[4]);
15199 digest
[0] -= SHA1M_A
;
15200 digest
[1] -= SHA1M_B
;
15201 digest
[2] -= SHA1M_C
;
15202 digest
[3] -= SHA1M_D
;
15203 digest
[4] -= SHA1M_E
;
15205 salt
->salt_buf
[0] = 0x80;
15207 salt
->salt_len
= 0;
15209 return (PARSER_OK
);
15212 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15214 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15216 u32
*digest
= (u32
*) hash_buf
->digest
;
15218 salt_t
*salt
= hash_buf
->salt
;
15220 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15221 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15222 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15223 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15225 digest
[0] = byte_swap_32 (digest
[0]);
15226 digest
[1] = byte_swap_32 (digest
[1]);
15227 digest
[2] = byte_swap_32 (digest
[2]);
15228 digest
[3] = byte_swap_32 (digest
[3]);
15230 digest
[0] -= MD5M_A
;
15231 digest
[1] -= MD5M_B
;
15232 digest
[2] -= MD5M_C
;
15233 digest
[3] -= MD5M_D
;
15235 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15237 uint salt_len
= input_len
- 32 - 1;
15239 char *salt_buf
= input_buf
+ 32 + 1;
15241 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15243 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15245 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15248 * add static "salt" part
15251 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15255 salt
->salt_len
= salt_len
;
15257 return (PARSER_OK
);
15260 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15262 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15264 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15266 u32
*digest
= (u32
*) hash_buf
->digest
;
15268 salt_t
*salt
= hash_buf
->salt
;
15270 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15276 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15278 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15280 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15282 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15284 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15288 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15290 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15292 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15294 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15298 char *keybuf_pos
= strchr (keylen_pos
, '$');
15300 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15302 uint keylen_len
= keybuf_pos
- keylen_pos
;
15304 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15308 char *databuf_pos
= strchr (keybuf_pos
, '$');
15310 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15312 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15314 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15318 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15320 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15326 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15327 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15328 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15329 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15331 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15332 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15333 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15334 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15336 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15337 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15338 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15339 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15341 salt
->salt_len
= 16;
15342 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15344 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15346 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15349 return (PARSER_OK
);
15352 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15354 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15356 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15358 u32
*digest
= (u32
*) hash_buf
->digest
;
15360 salt_t
*salt
= hash_buf
->salt
;
15366 // first is the N salt parameter
15368 char *N_pos
= input_buf
+ 6;
15370 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15374 salt
->scrypt_N
= atoi (N_pos
);
15378 char *r_pos
= strchr (N_pos
, ':');
15380 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15384 salt
->scrypt_r
= atoi (r_pos
);
15388 char *p_pos
= strchr (r_pos
, ':');
15390 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15394 salt
->scrypt_p
= atoi (p_pos
);
15398 char *saltbuf_pos
= strchr (p_pos
, ':');
15400 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15404 char *hash_pos
= strchr (saltbuf_pos
, ':');
15406 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15414 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15416 u8 tmp_buf
[33] = { 0 };
15418 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15420 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15422 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15424 salt
->salt_len
= tmp_len
;
15425 salt
->salt_iter
= 1;
15427 // digest - base64 decode
15429 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15431 tmp_len
= input_len
- (hash_pos
- input_buf
);
15433 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15435 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15437 memcpy (digest
, tmp_buf
, 32);
15439 return (PARSER_OK
);
15442 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15444 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15446 u32
*digest
= (u32
*) hash_buf
->digest
;
15448 salt_t
*salt
= hash_buf
->salt
;
15454 char decrypted
[76] = { 0 }; // iv + hash
15456 juniper_decrypt_hash (input_buf
, decrypted
);
15458 char *md5crypt_hash
= decrypted
+ 12;
15460 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15462 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15464 char *salt_pos
= md5crypt_hash
+ 3;
15466 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15468 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15470 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15474 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15476 return (PARSER_OK
);
15479 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15481 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15483 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15485 u32
*digest
= (u32
*) hash_buf
->digest
;
15487 salt_t
*salt
= hash_buf
->salt
;
15489 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15495 // first is *raw* salt
15497 char *salt_pos
= input_buf
+ 3;
15499 char *hash_pos
= strchr (salt_pos
, '$');
15501 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 uint salt_len
= hash_pos
- salt_pos
;
15505 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15509 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15511 memcpy (salt_buf_ptr
, salt_pos
, 14);
15513 salt_buf_ptr
[17] = 0x01;
15514 salt_buf_ptr
[18] = 0x80;
15516 // add some stuff to normal salt to make sorted happy
15518 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15519 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15520 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15521 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15523 salt
->salt_len
= salt_len
;
15524 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15526 // base64 decode hash
15528 u8 tmp_buf
[100] = { 0 };
15530 uint hash_len
= input_len
- 3 - salt_len
- 1;
15532 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15534 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15536 memcpy (digest
, tmp_buf
, 32);
15538 digest
[0] = byte_swap_32 (digest
[0]);
15539 digest
[1] = byte_swap_32 (digest
[1]);
15540 digest
[2] = byte_swap_32 (digest
[2]);
15541 digest
[3] = byte_swap_32 (digest
[3]);
15542 digest
[4] = byte_swap_32 (digest
[4]);
15543 digest
[5] = byte_swap_32 (digest
[5]);
15544 digest
[6] = byte_swap_32 (digest
[6]);
15545 digest
[7] = byte_swap_32 (digest
[7]);
15547 return (PARSER_OK
);
15550 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15552 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15554 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15556 u32
*digest
= (u32
*) hash_buf
->digest
;
15558 salt_t
*salt
= hash_buf
->salt
;
15564 // first is *raw* salt
15566 char *salt_pos
= input_buf
+ 3;
15568 char *hash_pos
= strchr (salt_pos
, '$');
15570 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15572 uint salt_len
= hash_pos
- salt_pos
;
15574 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15576 salt
->salt_len
= salt_len
;
15579 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15581 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15582 salt_buf_ptr
[salt_len
] = 0;
15584 // base64 decode hash
15586 u8 tmp_buf
[100] = { 0 };
15588 uint hash_len
= input_len
- 3 - salt_len
- 1;
15590 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15592 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15594 memcpy (digest
, tmp_buf
, 32);
15597 salt
->scrypt_N
= 16384;
15598 salt
->scrypt_r
= 1;
15599 salt
->scrypt_p
= 1;
15600 salt
->salt_iter
= 1;
15602 return (PARSER_OK
);
15605 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15607 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15609 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15611 u32
*digest
= (u32
*) hash_buf
->digest
;
15613 salt_t
*salt
= hash_buf
->salt
;
15615 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15621 char *version_pos
= input_buf
+ 8 + 1;
15623 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15625 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15627 u32 version_len
= verifierHashSize_pos
- version_pos
;
15629 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15631 verifierHashSize_pos
++;
15633 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15635 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15637 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15639 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15643 char *saltSize_pos
= strchr (keySize_pos
, '*');
15645 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15647 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15649 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15653 char *osalt_pos
= strchr (saltSize_pos
, '*');
15655 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15657 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15659 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15663 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15665 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15667 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15669 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15671 encryptedVerifier_pos
++;
15673 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15675 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15677 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15679 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15681 encryptedVerifierHash_pos
++;
15683 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;
15685 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15687 const uint version
= atoi (version_pos
);
15689 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15691 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15693 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15695 const uint keySize
= atoi (keySize_pos
);
15697 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15699 office2007
->keySize
= keySize
;
15701 const uint saltSize
= atoi (saltSize_pos
);
15703 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15709 salt
->salt_len
= 16;
15710 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15712 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15713 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15714 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15715 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15721 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15722 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15723 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15724 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15726 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15727 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15728 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15729 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15730 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15736 digest
[0] = office2007
->encryptedVerifierHash
[0];
15737 digest
[1] = office2007
->encryptedVerifierHash
[1];
15738 digest
[2] = office2007
->encryptedVerifierHash
[2];
15739 digest
[3] = office2007
->encryptedVerifierHash
[3];
15741 return (PARSER_OK
);
15744 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15746 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15748 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15750 u32
*digest
= (u32
*) hash_buf
->digest
;
15752 salt_t
*salt
= hash_buf
->salt
;
15754 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15760 char *version_pos
= input_buf
+ 8 + 1;
15762 char *spinCount_pos
= strchr (version_pos
, '*');
15764 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15766 u32 version_len
= spinCount_pos
- version_pos
;
15768 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15772 char *keySize_pos
= strchr (spinCount_pos
, '*');
15774 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15776 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15778 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15782 char *saltSize_pos
= strchr (keySize_pos
, '*');
15784 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15786 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15788 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15792 char *osalt_pos
= strchr (saltSize_pos
, '*');
15794 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15796 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15798 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15802 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15804 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15806 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15808 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15810 encryptedVerifier_pos
++;
15812 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15814 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15816 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15818 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15820 encryptedVerifierHash_pos
++;
15822 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;
15824 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15826 const uint version
= atoi (version_pos
);
15828 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15830 const uint spinCount
= atoi (spinCount_pos
);
15832 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15834 const uint keySize
= atoi (keySize_pos
);
15836 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15838 const uint saltSize
= atoi (saltSize_pos
);
15840 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15846 salt
->salt_len
= 16;
15847 salt
->salt_iter
= spinCount
;
15849 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15850 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15851 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15852 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15858 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15859 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15860 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15861 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15863 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15864 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15865 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15866 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15867 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15868 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15869 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15870 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15876 digest
[0] = office2010
->encryptedVerifierHash
[0];
15877 digest
[1] = office2010
->encryptedVerifierHash
[1];
15878 digest
[2] = office2010
->encryptedVerifierHash
[2];
15879 digest
[3] = office2010
->encryptedVerifierHash
[3];
15881 return (PARSER_OK
);
15884 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15886 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15888 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15890 u32
*digest
= (u32
*) hash_buf
->digest
;
15892 salt_t
*salt
= hash_buf
->salt
;
15894 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15900 char *version_pos
= input_buf
+ 8 + 1;
15902 char *spinCount_pos
= strchr (version_pos
, '*');
15904 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15906 u32 version_len
= spinCount_pos
- version_pos
;
15908 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15912 char *keySize_pos
= strchr (spinCount_pos
, '*');
15914 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15916 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15918 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15922 char *saltSize_pos
= strchr (keySize_pos
, '*');
15924 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15926 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15928 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15932 char *osalt_pos
= strchr (saltSize_pos
, '*');
15934 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15936 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15938 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15942 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15944 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15946 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15948 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15950 encryptedVerifier_pos
++;
15952 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15954 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15956 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15958 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15960 encryptedVerifierHash_pos
++;
15962 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;
15964 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15966 const uint version
= atoi (version_pos
);
15968 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15970 const uint spinCount
= atoi (spinCount_pos
);
15972 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15974 const uint keySize
= atoi (keySize_pos
);
15976 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15978 const uint saltSize
= atoi (saltSize_pos
);
15980 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15986 salt
->salt_len
= 16;
15987 salt
->salt_iter
= spinCount
;
15989 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15990 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15991 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15992 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15998 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15999 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16000 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16001 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16003 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16004 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16005 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16006 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16007 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16008 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16009 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16010 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16016 digest
[0] = office2013
->encryptedVerifierHash
[0];
16017 digest
[1] = office2013
->encryptedVerifierHash
[1];
16018 digest
[2] = office2013
->encryptedVerifierHash
[2];
16019 digest
[3] = office2013
->encryptedVerifierHash
[3];
16021 return (PARSER_OK
);
16024 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16026 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16028 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16030 u32
*digest
= (u32
*) hash_buf
->digest
;
16032 salt_t
*salt
= hash_buf
->salt
;
16034 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16040 char *version_pos
= input_buf
+ 11;
16042 char *osalt_pos
= strchr (version_pos
, '*');
16044 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16046 u32 version_len
= osalt_pos
- version_pos
;
16048 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16052 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16054 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16056 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16058 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16060 encryptedVerifier_pos
++;
16062 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16064 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16066 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16068 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16070 encryptedVerifierHash_pos
++;
16072 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16074 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16076 const uint version
= *version_pos
- 0x30;
16078 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16084 oldoffice01
->version
= version
;
16086 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16087 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16088 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16089 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16091 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16092 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16093 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16094 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16096 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16097 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16098 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16099 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16101 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16102 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16103 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16104 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16110 salt
->salt_len
= 16;
16112 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16113 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16114 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16115 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16117 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16118 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16119 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16120 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16122 // this is a workaround as office produces multiple documents with the same salt
16124 salt
->salt_len
+= 32;
16126 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16127 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16128 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16129 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16130 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16131 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16132 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16133 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16139 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16140 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16141 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16142 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16144 return (PARSER_OK
);
16147 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16149 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16152 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16154 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16156 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16158 u32
*digest
= (u32
*) hash_buf
->digest
;
16160 salt_t
*salt
= hash_buf
->salt
;
16162 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16168 char *version_pos
= input_buf
+ 11;
16170 char *osalt_pos
= strchr (version_pos
, '*');
16172 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16174 u32 version_len
= osalt_pos
- version_pos
;
16176 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16180 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16182 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16184 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16186 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16188 encryptedVerifier_pos
++;
16190 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16192 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16194 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16196 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16198 encryptedVerifierHash_pos
++;
16200 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16202 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16204 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16206 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16210 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16212 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16214 const uint version
= *version_pos
- 0x30;
16216 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16222 oldoffice01
->version
= version
;
16224 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16225 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16226 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16227 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16229 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16230 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16231 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16232 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16234 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16235 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16236 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16237 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16239 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16240 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16241 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16242 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16244 oldoffice01
->rc4key
[1] = 0;
16245 oldoffice01
->rc4key
[0] = 0;
16247 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16248 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16249 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16250 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16251 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16252 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16253 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16254 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16255 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16256 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16258 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16259 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16265 salt
->salt_len
= 16;
16267 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16268 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16269 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16270 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16272 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16273 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16274 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16275 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16277 // this is a workaround as office produces multiple documents with the same salt
16279 salt
->salt_len
+= 32;
16281 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16282 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16283 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16284 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16285 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16286 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16287 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16288 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16294 digest
[0] = oldoffice01
->rc4key
[0];
16295 digest
[1] = oldoffice01
->rc4key
[1];
16299 return (PARSER_OK
);
16302 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16304 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16306 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16308 u32
*digest
= (u32
*) hash_buf
->digest
;
16310 salt_t
*salt
= hash_buf
->salt
;
16312 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16318 char *version_pos
= input_buf
+ 11;
16320 char *osalt_pos
= strchr (version_pos
, '*');
16322 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16324 u32 version_len
= osalt_pos
- version_pos
;
16326 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16330 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16332 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16336 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16338 encryptedVerifier_pos
++;
16340 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16342 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16344 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16346 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16348 encryptedVerifierHash_pos
++;
16350 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16352 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16354 const uint version
= *version_pos
- 0x30;
16356 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16362 oldoffice34
->version
= version
;
16364 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16365 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16366 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16367 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16369 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16370 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16371 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16372 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16374 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16375 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16376 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16377 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16378 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16380 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16381 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16382 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16383 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16384 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16390 salt
->salt_len
= 16;
16392 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16393 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16394 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16395 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16397 // this is a workaround as office produces multiple documents with the same salt
16399 salt
->salt_len
+= 32;
16401 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16402 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16403 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16404 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16405 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16406 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16407 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16408 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16414 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16415 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16416 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16417 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16419 return (PARSER_OK
);
16422 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16424 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16426 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16429 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16431 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16433 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16435 u32
*digest
= (u32
*) hash_buf
->digest
;
16437 salt_t
*salt
= hash_buf
->salt
;
16439 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16445 char *version_pos
= input_buf
+ 11;
16447 char *osalt_pos
= strchr (version_pos
, '*');
16449 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16451 u32 version_len
= osalt_pos
- version_pos
;
16453 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16457 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16459 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16461 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16463 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16465 encryptedVerifier_pos
++;
16467 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16469 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16471 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16473 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16475 encryptedVerifierHash_pos
++;
16477 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16479 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16481 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16483 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16487 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16489 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16491 const uint version
= *version_pos
- 0x30;
16493 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16499 oldoffice34
->version
= version
;
16501 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16502 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16503 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16504 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16506 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16507 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16508 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16509 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16511 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16512 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16513 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16514 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16515 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16517 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16518 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16519 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16520 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16521 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16523 oldoffice34
->rc4key
[1] = 0;
16524 oldoffice34
->rc4key
[0] = 0;
16526 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16527 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16528 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16529 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16530 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16531 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16532 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16533 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16534 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16535 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16537 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16538 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16544 salt
->salt_len
= 16;
16546 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16547 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16548 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16549 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16551 // this is a workaround as office produces multiple documents with the same salt
16553 salt
->salt_len
+= 32;
16555 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16556 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16557 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16558 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16559 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16560 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16561 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16562 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16568 digest
[0] = oldoffice34
->rc4key
[0];
16569 digest
[1] = oldoffice34
->rc4key
[1];
16573 return (PARSER_OK
);
16576 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16578 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16580 u32
*digest
= (u32
*) hash_buf
->digest
;
16582 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16583 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16584 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16585 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16587 digest
[0] = byte_swap_32 (digest
[0]);
16588 digest
[1] = byte_swap_32 (digest
[1]);
16589 digest
[2] = byte_swap_32 (digest
[2]);
16590 digest
[3] = byte_swap_32 (digest
[3]);
16592 return (PARSER_OK
);
16595 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16597 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16599 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16601 u32
*digest
= (u32
*) hash_buf
->digest
;
16603 salt_t
*salt
= hash_buf
->salt
;
16605 char *signature_pos
= input_buf
;
16607 char *salt_pos
= strchr (signature_pos
, '$');
16609 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16611 u32 signature_len
= salt_pos
- signature_pos
;
16613 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16617 char *hash_pos
= strchr (salt_pos
, '$');
16619 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16621 u32 salt_len
= hash_pos
- salt_pos
;
16623 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16627 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16629 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16631 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16632 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16633 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16634 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16635 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16637 digest
[0] -= SHA1M_A
;
16638 digest
[1] -= SHA1M_B
;
16639 digest
[2] -= SHA1M_C
;
16640 digest
[3] -= SHA1M_D
;
16641 digest
[4] -= SHA1M_E
;
16643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16645 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16647 salt
->salt_len
= salt_len
;
16649 return (PARSER_OK
);
16652 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16654 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16656 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16658 u32
*digest
= (u32
*) hash_buf
->digest
;
16660 salt_t
*salt
= hash_buf
->salt
;
16662 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16668 char *iter_pos
= input_buf
+ 14;
16670 const int iter
= atoi (iter_pos
);
16672 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16674 salt
->salt_iter
= iter
- 1;
16676 char *salt_pos
= strchr (iter_pos
, '$');
16678 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16682 char *hash_pos
= strchr (salt_pos
, '$');
16684 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16686 const uint salt_len
= hash_pos
- salt_pos
;
16690 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16692 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16694 salt
->salt_len
= salt_len
;
16696 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16697 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16699 // add some stuff to normal salt to make sorted happy
16701 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16702 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16703 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16704 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16705 salt
->salt_buf
[4] = salt
->salt_iter
;
16707 // base64 decode hash
16709 u8 tmp_buf
[100] = { 0 };
16711 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16713 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16715 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16717 memcpy (digest
, tmp_buf
, 32);
16719 digest
[0] = byte_swap_32 (digest
[0]);
16720 digest
[1] = byte_swap_32 (digest
[1]);
16721 digest
[2] = byte_swap_32 (digest
[2]);
16722 digest
[3] = byte_swap_32 (digest
[3]);
16723 digest
[4] = byte_swap_32 (digest
[4]);
16724 digest
[5] = byte_swap_32 (digest
[5]);
16725 digest
[6] = byte_swap_32 (digest
[6]);
16726 digest
[7] = byte_swap_32 (digest
[7]);
16728 return (PARSER_OK
);
16731 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16733 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16735 u32
*digest
= (u32
*) hash_buf
->digest
;
16737 salt_t
*salt
= hash_buf
->salt
;
16739 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16740 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16744 digest
[0] = byte_swap_32 (digest
[0]);
16745 digest
[1] = byte_swap_32 (digest
[1]);
16747 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16748 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16749 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16751 char iter_c
= input_buf
[17];
16752 char iter_d
= input_buf
[19];
16754 // atm only defaults, let's see if there's more request
16755 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16756 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16758 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16760 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16761 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16762 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16763 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16765 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16766 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16767 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16768 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16770 salt
->salt_len
= 16;
16772 return (PARSER_OK
);
16775 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16777 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16779 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16781 u32
*digest
= (u32
*) hash_buf
->digest
;
16783 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16785 salt_t
*salt
= hash_buf
->salt
;
16787 char *salt_pos
= input_buf
+ 10;
16789 char *hash_pos
= strchr (salt_pos
, '$');
16791 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16793 uint salt_len
= hash_pos
- salt_pos
;
16797 uint hash_len
= input_len
- 10 - salt_len
- 1;
16799 // base64 decode salt
16801 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16803 u8 tmp_buf
[100] = { 0 };
16805 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16807 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16809 tmp_buf
[salt_len
] = 0x80;
16811 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16813 salt
->salt_len
= salt_len
;
16815 // base64 decode hash
16817 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16819 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16821 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16823 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16825 uint user_len
= hash_len
- 32;
16827 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16829 user_len
--; // skip the trailing space
16831 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16832 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16833 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16834 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16836 digest
[0] = byte_swap_32 (digest
[0]);
16837 digest
[1] = byte_swap_32 (digest
[1]);
16838 digest
[2] = byte_swap_32 (digest
[2]);
16839 digest
[3] = byte_swap_32 (digest
[3]);
16841 // store username for host only (output hash if cracked)
16843 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16844 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16846 return (PARSER_OK
);
16849 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16851 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16853 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16855 u32
*digest
= (u32
*) hash_buf
->digest
;
16857 salt_t
*salt
= hash_buf
->salt
;
16859 char *iter_pos
= input_buf
+ 10;
16861 u32 iter
= atoi (iter_pos
);
16865 return (PARSER_SALT_ITERATION
);
16868 iter
--; // first iteration is special
16870 salt
->salt_iter
= iter
;
16872 char *base64_pos
= strchr (iter_pos
, '}');
16874 if (base64_pos
== NULL
)
16876 return (PARSER_SIGNATURE_UNMATCHED
);
16881 // base64 decode salt
16883 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16885 u8 tmp_buf
[100] = { 0 };
16887 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16889 if (decoded_len
< 24)
16891 return (PARSER_SALT_LENGTH
);
16896 uint salt_len
= decoded_len
- 20;
16898 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16899 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16901 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16903 salt
->salt_len
= salt_len
;
16907 u32
*digest_ptr
= (u32
*) tmp_buf
;
16909 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16910 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16911 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16912 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16913 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16915 return (PARSER_OK
);
16918 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16920 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16922 u32
*digest
= (u32
*) hash_buf
->digest
;
16924 salt_t
*salt
= hash_buf
->salt
;
16926 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16927 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16928 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16929 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16930 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16932 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16934 uint salt_len
= input_len
- 40 - 1;
16936 char *salt_buf
= input_buf
+ 40 + 1;
16938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16940 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16942 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16944 salt
->salt_len
= salt_len
;
16946 return (PARSER_OK
);
16949 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16951 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16953 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16955 u32
*digest
= (u32
*) hash_buf
->digest
;
16957 salt_t
*salt
= hash_buf
->salt
;
16959 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16965 char *V_pos
= input_buf
+ 5;
16967 char *R_pos
= strchr (V_pos
, '*');
16969 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16971 u32 V_len
= R_pos
- V_pos
;
16975 char *bits_pos
= strchr (R_pos
, '*');
16977 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16979 u32 R_len
= bits_pos
- R_pos
;
16983 char *P_pos
= strchr (bits_pos
, '*');
16985 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16987 u32 bits_len
= P_pos
- bits_pos
;
16991 char *enc_md_pos
= strchr (P_pos
, '*');
16993 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16995 u32 P_len
= enc_md_pos
- P_pos
;
16999 char *id_len_pos
= strchr (enc_md_pos
, '*');
17001 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17003 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17007 char *id_buf_pos
= strchr (id_len_pos
, '*');
17009 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17011 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17015 char *u_len_pos
= strchr (id_buf_pos
, '*');
17017 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17019 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17021 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17025 char *u_buf_pos
= strchr (u_len_pos
, '*');
17027 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17029 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17033 char *o_len_pos
= strchr (u_buf_pos
, '*');
17035 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17037 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17039 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17043 char *o_buf_pos
= strchr (o_len_pos
, '*');
17045 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17047 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17051 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;
17053 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17057 const int V
= atoi (V_pos
);
17058 const int R
= atoi (R_pos
);
17059 const int P
= atoi (P_pos
);
17061 if (V
!= 1) return (PARSER_SALT_VALUE
);
17062 if (R
!= 2) return (PARSER_SALT_VALUE
);
17064 const int enc_md
= atoi (enc_md_pos
);
17066 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17068 const int id_len
= atoi (id_len_pos
);
17069 const int u_len
= atoi (u_len_pos
);
17070 const int o_len
= atoi (o_len_pos
);
17072 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17073 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17074 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17076 const int bits
= atoi (bits_pos
);
17078 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17080 // copy data to esalt
17086 pdf
->enc_md
= enc_md
;
17088 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17089 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17090 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17091 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17092 pdf
->id_len
= id_len
;
17094 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17095 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17096 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17097 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17098 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17099 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17100 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17101 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17102 pdf
->u_len
= u_len
;
17104 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17105 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17106 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17107 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17108 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17109 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17110 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17111 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17112 pdf
->o_len
= o_len
;
17114 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17115 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17116 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17117 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17119 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17120 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17121 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17122 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17123 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17124 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17125 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17126 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17128 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17129 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17130 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17131 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17132 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17133 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17134 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17135 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17137 // we use ID for salt, maybe needs to change, we will see...
17139 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17140 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17141 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17142 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17143 salt
->salt_len
= pdf
->id_len
;
17145 digest
[0] = pdf
->u_buf
[0];
17146 digest
[1] = pdf
->u_buf
[1];
17147 digest
[2] = pdf
->u_buf
[2];
17148 digest
[3] = pdf
->u_buf
[3];
17150 return (PARSER_OK
);
17153 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17155 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17158 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17160 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17162 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17164 u32
*digest
= (u32
*) hash_buf
->digest
;
17166 salt_t
*salt
= hash_buf
->salt
;
17168 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17174 char *V_pos
= input_buf
+ 5;
17176 char *R_pos
= strchr (V_pos
, '*');
17178 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17180 u32 V_len
= R_pos
- V_pos
;
17184 char *bits_pos
= strchr (R_pos
, '*');
17186 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17188 u32 R_len
= bits_pos
- R_pos
;
17192 char *P_pos
= strchr (bits_pos
, '*');
17194 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17196 u32 bits_len
= P_pos
- bits_pos
;
17200 char *enc_md_pos
= strchr (P_pos
, '*');
17202 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17204 u32 P_len
= enc_md_pos
- P_pos
;
17208 char *id_len_pos
= strchr (enc_md_pos
, '*');
17210 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17212 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17216 char *id_buf_pos
= strchr (id_len_pos
, '*');
17218 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17220 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17224 char *u_len_pos
= strchr (id_buf_pos
, '*');
17226 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17228 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17230 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17234 char *u_buf_pos
= strchr (u_len_pos
, '*');
17236 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17238 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17242 char *o_len_pos
= strchr (u_buf_pos
, '*');
17244 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17246 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17248 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17252 char *o_buf_pos
= strchr (o_len_pos
, '*');
17254 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17256 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17260 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17262 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17264 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17266 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17270 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;
17272 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17276 const int V
= atoi (V_pos
);
17277 const int R
= atoi (R_pos
);
17278 const int P
= atoi (P_pos
);
17280 if (V
!= 1) return (PARSER_SALT_VALUE
);
17281 if (R
!= 2) return (PARSER_SALT_VALUE
);
17283 const int enc_md
= atoi (enc_md_pos
);
17285 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17287 const int id_len
= atoi (id_len_pos
);
17288 const int u_len
= atoi (u_len_pos
);
17289 const int o_len
= atoi (o_len_pos
);
17291 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17292 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17293 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17295 const int bits
= atoi (bits_pos
);
17297 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17299 // copy data to esalt
17305 pdf
->enc_md
= enc_md
;
17307 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17308 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17309 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17310 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17311 pdf
->id_len
= id_len
;
17313 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17314 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17315 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17316 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17317 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17318 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17319 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17320 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17321 pdf
->u_len
= u_len
;
17323 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17324 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17325 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17326 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17327 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17328 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17329 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17330 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17331 pdf
->o_len
= o_len
;
17333 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17334 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17335 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17336 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17338 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17339 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17340 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17341 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17342 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17343 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17344 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17345 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17347 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17348 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17349 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17350 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17351 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17352 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17353 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17354 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17356 pdf
->rc4key
[1] = 0;
17357 pdf
->rc4key
[0] = 0;
17359 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17360 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17361 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17362 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17363 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17364 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17365 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17366 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17367 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17368 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17370 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17371 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17373 // we use ID for salt, maybe needs to change, we will see...
17375 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17376 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17377 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17378 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17379 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17380 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17381 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17382 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17383 salt
->salt_len
= pdf
->id_len
+ 16;
17385 digest
[0] = pdf
->rc4key
[0];
17386 digest
[1] = pdf
->rc4key
[1];
17390 return (PARSER_OK
);
17393 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17395 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17397 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17399 u32
*digest
= (u32
*) hash_buf
->digest
;
17401 salt_t
*salt
= hash_buf
->salt
;
17403 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17409 char *V_pos
= input_buf
+ 5;
17411 char *R_pos
= strchr (V_pos
, '*');
17413 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17415 u32 V_len
= R_pos
- V_pos
;
17419 char *bits_pos
= strchr (R_pos
, '*');
17421 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17423 u32 R_len
= bits_pos
- R_pos
;
17427 char *P_pos
= strchr (bits_pos
, '*');
17429 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17431 u32 bits_len
= P_pos
- bits_pos
;
17435 char *enc_md_pos
= strchr (P_pos
, '*');
17437 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17439 u32 P_len
= enc_md_pos
- P_pos
;
17443 char *id_len_pos
= strchr (enc_md_pos
, '*');
17445 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17447 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17451 char *id_buf_pos
= strchr (id_len_pos
, '*');
17453 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17455 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17459 char *u_len_pos
= strchr (id_buf_pos
, '*');
17461 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17463 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17465 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17469 char *u_buf_pos
= strchr (u_len_pos
, '*');
17471 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17473 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17477 char *o_len_pos
= strchr (u_buf_pos
, '*');
17479 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17481 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17483 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17487 char *o_buf_pos
= strchr (o_len_pos
, '*');
17489 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17491 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17495 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;
17497 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17501 const int V
= atoi (V_pos
);
17502 const int R
= atoi (R_pos
);
17503 const int P
= atoi (P_pos
);
17507 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17508 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17510 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17512 const int id_len
= atoi (id_len_pos
);
17513 const int u_len
= atoi (u_len_pos
);
17514 const int o_len
= atoi (o_len_pos
);
17516 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17518 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17519 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17521 const int bits
= atoi (bits_pos
);
17523 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17529 enc_md
= atoi (enc_md_pos
);
17532 // copy data to esalt
17538 pdf
->enc_md
= enc_md
;
17540 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17541 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17542 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17543 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17547 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17548 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17549 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17550 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17553 pdf
->id_len
= id_len
;
17555 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17556 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17557 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17558 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17559 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17560 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17561 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17562 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17563 pdf
->u_len
= u_len
;
17565 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17566 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17567 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17568 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17569 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17570 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17571 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17572 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17573 pdf
->o_len
= o_len
;
17575 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17576 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17577 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17578 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17582 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17583 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17584 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17585 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17588 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17589 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17590 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17591 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17592 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17593 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17594 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17595 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17597 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17598 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17599 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17600 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17601 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17602 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17603 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17604 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17606 // precompute rc4 data for later use
17622 uint salt_pc_block
[32] = { 0 };
17624 char *salt_pc_ptr
= (char *) salt_pc_block
;
17626 memcpy (salt_pc_ptr
, padding
, 32);
17627 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17629 uint salt_pc_digest
[4] = { 0 };
17631 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17633 pdf
->rc4data
[0] = salt_pc_digest
[0];
17634 pdf
->rc4data
[1] = salt_pc_digest
[1];
17636 // we use ID for salt, maybe needs to change, we will see...
17638 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17639 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17640 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17641 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17642 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17643 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17644 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17645 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17646 salt
->salt_len
= pdf
->id_len
+ 16;
17648 salt
->salt_iter
= ROUNDS_PDF14
;
17650 digest
[0] = pdf
->u_buf
[0];
17651 digest
[1] = pdf
->u_buf
[1];
17655 return (PARSER_OK
);
17658 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17660 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17662 if (ret
!= PARSER_OK
)
17667 u32
*digest
= (u32
*) hash_buf
->digest
;
17669 salt_t
*salt
= hash_buf
->salt
;
17671 digest
[0] -= SHA256M_A
;
17672 digest
[1] -= SHA256M_B
;
17673 digest
[2] -= SHA256M_C
;
17674 digest
[3] -= SHA256M_D
;
17675 digest
[4] -= SHA256M_E
;
17676 digest
[5] -= SHA256M_F
;
17677 digest
[6] -= SHA256M_G
;
17678 digest
[7] -= SHA256M_H
;
17680 salt
->salt_buf
[2] = 0x80;
17682 return (PARSER_OK
);
17685 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17687 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17689 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17691 u32
*digest
= (u32
*) hash_buf
->digest
;
17693 salt_t
*salt
= hash_buf
->salt
;
17695 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17701 char *V_pos
= input_buf
+ 5;
17703 char *R_pos
= strchr (V_pos
, '*');
17705 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17707 u32 V_len
= R_pos
- V_pos
;
17711 char *bits_pos
= strchr (R_pos
, '*');
17713 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17715 u32 R_len
= bits_pos
- R_pos
;
17719 char *P_pos
= strchr (bits_pos
, '*');
17721 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17723 u32 bits_len
= P_pos
- bits_pos
;
17727 char *enc_md_pos
= strchr (P_pos
, '*');
17729 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17731 u32 P_len
= enc_md_pos
- P_pos
;
17735 char *id_len_pos
= strchr (enc_md_pos
, '*');
17737 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17739 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17743 char *id_buf_pos
= strchr (id_len_pos
, '*');
17745 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17747 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17751 char *u_len_pos
= strchr (id_buf_pos
, '*');
17753 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17755 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17759 char *u_buf_pos
= strchr (u_len_pos
, '*');
17761 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17763 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17767 char *o_len_pos
= strchr (u_buf_pos
, '*');
17769 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17771 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17775 char *o_buf_pos
= strchr (o_len_pos
, '*');
17777 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17779 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17783 char *last
= strchr (o_buf_pos
, '*');
17785 if (last
== NULL
) last
= input_buf
+ input_len
;
17787 u32 o_buf_len
= last
- o_buf_pos
;
17791 const int V
= atoi (V_pos
);
17792 const int R
= atoi (R_pos
);
17796 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17797 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17799 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17801 const int bits
= atoi (bits_pos
);
17803 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17805 int enc_md
= atoi (enc_md_pos
);
17807 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17809 const uint id_len
= atoi (id_len_pos
);
17810 const uint u_len
= atoi (u_len_pos
);
17811 const uint o_len
= atoi (o_len_pos
);
17813 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17814 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17815 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17816 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17817 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17818 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17819 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17820 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17822 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17823 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17824 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17826 // copy data to esalt
17828 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17830 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17832 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17835 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17836 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17838 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17839 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17841 salt
->salt_len
= 8;
17842 salt
->salt_iter
= ROUNDS_PDF17L8
;
17844 digest
[0] = pdf
->u_buf
[0];
17845 digest
[1] = pdf
->u_buf
[1];
17846 digest
[2] = pdf
->u_buf
[2];
17847 digest
[3] = pdf
->u_buf
[3];
17848 digest
[4] = pdf
->u_buf
[4];
17849 digest
[5] = pdf
->u_buf
[5];
17850 digest
[6] = pdf
->u_buf
[6];
17851 digest
[7] = pdf
->u_buf
[7];
17853 return (PARSER_OK
);
17856 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17858 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17860 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17862 u32
*digest
= (u32
*) hash_buf
->digest
;
17864 salt_t
*salt
= hash_buf
->salt
;
17866 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17874 char *iter_pos
= input_buf
+ 7;
17876 u32 iter
= atoi (iter_pos
);
17878 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17879 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17881 // first is *raw* salt
17883 char *salt_pos
= strchr (iter_pos
, ':');
17885 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17889 char *hash_pos
= strchr (salt_pos
, ':');
17891 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17893 u32 salt_len
= hash_pos
- salt_pos
;
17895 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17899 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17901 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17905 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17907 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17909 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17911 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17912 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17914 salt
->salt_len
= salt_len
;
17915 salt
->salt_iter
= iter
- 1;
17919 u8 tmp_buf
[100] = { 0 };
17921 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17923 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17925 memcpy (digest
, tmp_buf
, 16);
17927 digest
[0] = byte_swap_32 (digest
[0]);
17928 digest
[1] = byte_swap_32 (digest
[1]);
17929 digest
[2] = byte_swap_32 (digest
[2]);
17930 digest
[3] = byte_swap_32 (digest
[3]);
17932 // add some stuff to normal salt to make sorted happy
17934 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17935 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17936 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17937 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17938 salt
->salt_buf
[4] = salt
->salt_iter
;
17940 return (PARSER_OK
);
17943 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17945 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17947 u32
*digest
= (u32
*) hash_buf
->digest
;
17949 salt_t
*salt
= hash_buf
->salt
;
17951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17953 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17954 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17956 digest
[0] = byte_swap_32 (digest
[0]);
17957 digest
[1] = byte_swap_32 (digest
[1]);
17958 digest
[2] = byte_swap_32 (digest
[2]);
17959 digest
[3] = byte_swap_32 (digest
[3]);
17961 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17963 uint salt_len
= input_len
- 32 - 1;
17965 char *salt_buf
= input_buf
+ 32 + 1;
17967 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17969 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17971 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17973 salt
->salt_len
= salt_len
;
17975 return (PARSER_OK
);
17978 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17980 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17982 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17984 u32
*digest
= (u32
*) hash_buf
->digest
;
17986 salt_t
*salt
= hash_buf
->salt
;
17988 char *user_pos
= input_buf
+ 10;
17990 char *salt_pos
= strchr (user_pos
, '*');
17992 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17996 char *hash_pos
= strchr (salt_pos
, '*');
18000 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18002 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18004 uint user_len
= salt_pos
- user_pos
- 1;
18006 uint salt_len
= hash_pos
- salt_pos
- 1;
18008 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18014 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18015 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18016 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18017 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18019 digest
[0] = byte_swap_32 (digest
[0]);
18020 digest
[1] = byte_swap_32 (digest
[1]);
18021 digest
[2] = byte_swap_32 (digest
[2]);
18022 digest
[3] = byte_swap_32 (digest
[3]);
18024 digest
[0] -= MD5M_A
;
18025 digest
[1] -= MD5M_B
;
18026 digest
[2] -= MD5M_C
;
18027 digest
[3] -= MD5M_D
;
18033 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18035 // first 4 bytes are the "challenge"
18037 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18038 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18039 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18040 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18042 // append the user name
18044 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18046 salt
->salt_len
= 4 + user_len
;
18048 return (PARSER_OK
);
18051 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18053 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18055 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18057 u32
*digest
= (u32
*) hash_buf
->digest
;
18059 salt_t
*salt
= hash_buf
->salt
;
18061 char *salt_pos
= input_buf
+ 9;
18063 char *hash_pos
= strchr (salt_pos
, '*');
18065 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18069 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18071 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18073 uint salt_len
= hash_pos
- salt_pos
- 1;
18075 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18081 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18082 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18083 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18084 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18085 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18093 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18095 salt
->salt_len
= salt_len
;
18097 return (PARSER_OK
);
18100 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18102 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18104 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18106 u32
*digest
= (u32
*) hash_buf
->digest
;
18108 salt_t
*salt
= hash_buf
->salt
;
18110 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18116 char *cry_master_len_pos
= input_buf
+ 9;
18118 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18120 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18122 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18124 cry_master_buf_pos
++;
18126 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18128 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18130 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18132 cry_salt_len_pos
++;
18134 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18136 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18138 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18140 cry_salt_buf_pos
++;
18142 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18144 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18146 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18150 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18152 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18154 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18158 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18160 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18162 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18166 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18168 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18170 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18172 public_key_len_pos
++;
18174 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18176 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18178 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18180 public_key_buf_pos
++;
18182 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;
18184 const uint cry_master_len
= atoi (cry_master_len_pos
);
18185 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18186 const uint ckey_len
= atoi (ckey_len_pos
);
18187 const uint public_key_len
= atoi (public_key_len_pos
);
18189 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18190 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18191 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18192 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18194 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18196 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18198 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18201 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18203 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18205 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18208 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18210 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18212 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18215 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18216 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18217 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18220 * store digest (should be unique enought, hopefully)
18223 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18224 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18225 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18226 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18232 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18234 const uint cry_rounds
= atoi (cry_rounds_pos
);
18236 salt
->salt_iter
= cry_rounds
- 1;
18238 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18240 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18242 salt
->salt_len
= salt_len
;
18244 return (PARSER_OK
);
18247 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18249 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18251 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18253 u32
*digest
= (u32
*) hash_buf
->digest
;
18255 salt_t
*salt
= hash_buf
->salt
;
18257 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18259 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18261 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18263 memcpy (temp_input_buf
, input_buf
, input_len
);
18267 char *URI_server_pos
= temp_input_buf
+ 6;
18269 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18271 if (URI_client_pos
== NULL
)
18273 myfree (temp_input_buf
);
18275 return (PARSER_SEPARATOR_UNMATCHED
);
18278 URI_client_pos
[0] = 0;
18281 uint URI_server_len
= strlen (URI_server_pos
);
18283 if (URI_server_len
> 512)
18285 myfree (temp_input_buf
);
18287 return (PARSER_SALT_LENGTH
);
18292 char *user_pos
= strchr (URI_client_pos
, '*');
18294 if (user_pos
== NULL
)
18296 myfree (temp_input_buf
);
18298 return (PARSER_SEPARATOR_UNMATCHED
);
18304 uint URI_client_len
= strlen (URI_client_pos
);
18306 if (URI_client_len
> 512)
18308 myfree (temp_input_buf
);
18310 return (PARSER_SALT_LENGTH
);
18315 char *realm_pos
= strchr (user_pos
, '*');
18317 if (realm_pos
== NULL
)
18319 myfree (temp_input_buf
);
18321 return (PARSER_SEPARATOR_UNMATCHED
);
18327 uint user_len
= strlen (user_pos
);
18329 if (user_len
> 116)
18331 myfree (temp_input_buf
);
18333 return (PARSER_SALT_LENGTH
);
18338 char *method_pos
= strchr (realm_pos
, '*');
18340 if (method_pos
== NULL
)
18342 myfree (temp_input_buf
);
18344 return (PARSER_SEPARATOR_UNMATCHED
);
18350 uint realm_len
= strlen (realm_pos
);
18352 if (realm_len
> 116)
18354 myfree (temp_input_buf
);
18356 return (PARSER_SALT_LENGTH
);
18361 char *URI_prefix_pos
= strchr (method_pos
, '*');
18363 if (URI_prefix_pos
== NULL
)
18365 myfree (temp_input_buf
);
18367 return (PARSER_SEPARATOR_UNMATCHED
);
18370 URI_prefix_pos
[0] = 0;
18373 uint method_len
= strlen (method_pos
);
18375 if (method_len
> 246)
18377 myfree (temp_input_buf
);
18379 return (PARSER_SALT_LENGTH
);
18384 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18386 if (URI_resource_pos
== NULL
)
18388 myfree (temp_input_buf
);
18390 return (PARSER_SEPARATOR_UNMATCHED
);
18393 URI_resource_pos
[0] = 0;
18394 URI_resource_pos
++;
18396 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18398 if (URI_prefix_len
> 245)
18400 myfree (temp_input_buf
);
18402 return (PARSER_SALT_LENGTH
);
18407 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18409 if (URI_suffix_pos
== NULL
)
18411 myfree (temp_input_buf
);
18413 return (PARSER_SEPARATOR_UNMATCHED
);
18416 URI_suffix_pos
[0] = 0;
18419 uint URI_resource_len
= strlen (URI_resource_pos
);
18421 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18423 myfree (temp_input_buf
);
18425 return (PARSER_SALT_LENGTH
);
18430 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18432 if (nonce_pos
== NULL
)
18434 myfree (temp_input_buf
);
18436 return (PARSER_SEPARATOR_UNMATCHED
);
18442 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18444 if (URI_suffix_len
> 245)
18446 myfree (temp_input_buf
);
18448 return (PARSER_SALT_LENGTH
);
18453 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18455 if (nonce_client_pos
== NULL
)
18457 myfree (temp_input_buf
);
18459 return (PARSER_SEPARATOR_UNMATCHED
);
18462 nonce_client_pos
[0] = 0;
18463 nonce_client_pos
++;
18465 uint nonce_len
= strlen (nonce_pos
);
18467 if (nonce_len
< 1 || nonce_len
> 50)
18469 myfree (temp_input_buf
);
18471 return (PARSER_SALT_LENGTH
);
18476 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18478 if (nonce_count_pos
== NULL
)
18480 myfree (temp_input_buf
);
18482 return (PARSER_SEPARATOR_UNMATCHED
);
18485 nonce_count_pos
[0] = 0;
18488 uint nonce_client_len
= strlen (nonce_client_pos
);
18490 if (nonce_client_len
> 50)
18492 myfree (temp_input_buf
);
18494 return (PARSER_SALT_LENGTH
);
18499 char *qop_pos
= strchr (nonce_count_pos
, '*');
18501 if (qop_pos
== NULL
)
18503 myfree (temp_input_buf
);
18505 return (PARSER_SEPARATOR_UNMATCHED
);
18511 uint nonce_count_len
= strlen (nonce_count_pos
);
18513 if (nonce_count_len
> 50)
18515 myfree (temp_input_buf
);
18517 return (PARSER_SALT_LENGTH
);
18522 char *directive_pos
= strchr (qop_pos
, '*');
18524 if (directive_pos
== NULL
)
18526 myfree (temp_input_buf
);
18528 return (PARSER_SEPARATOR_UNMATCHED
);
18531 directive_pos
[0] = 0;
18534 uint qop_len
= strlen (qop_pos
);
18538 myfree (temp_input_buf
);
18540 return (PARSER_SALT_LENGTH
);
18545 char *digest_pos
= strchr (directive_pos
, '*');
18547 if (digest_pos
== NULL
)
18549 myfree (temp_input_buf
);
18551 return (PARSER_SEPARATOR_UNMATCHED
);
18557 uint directive_len
= strlen (directive_pos
);
18559 if (directive_len
!= 3)
18561 myfree (temp_input_buf
);
18563 return (PARSER_SALT_LENGTH
);
18566 if (memcmp (directive_pos
, "MD5", 3))
18568 log_info ("ERROR: only the MD5 directive is currently supported\n");
18570 myfree (temp_input_buf
);
18572 return (PARSER_SIP_AUTH_DIRECTIVE
);
18576 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18581 uint md5_max_len
= 4 * 64;
18583 uint md5_remaining_len
= md5_max_len
;
18585 uint tmp_md5_buf
[64] = { 0 };
18587 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18589 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18591 md5_len
+= method_len
+ 1;
18592 tmp_md5_ptr
+= method_len
+ 1;
18594 if (URI_prefix_len
> 0)
18596 md5_remaining_len
= md5_max_len
- md5_len
;
18598 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18600 md5_len
+= URI_prefix_len
+ 1;
18601 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18604 md5_remaining_len
= md5_max_len
- md5_len
;
18606 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18608 md5_len
+= URI_resource_len
;
18609 tmp_md5_ptr
+= URI_resource_len
;
18611 if (URI_suffix_len
> 0)
18613 md5_remaining_len
= md5_max_len
- md5_len
;
18615 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18617 md5_len
+= 1 + URI_suffix_len
;
18620 uint tmp_digest
[4] = { 0 };
18622 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18624 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18625 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18626 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18627 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18633 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18635 uint esalt_len
= 0;
18637 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18639 // there are 2 possibilities for the esalt:
18641 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18643 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18645 if (esalt_len
> max_esalt_len
)
18647 myfree (temp_input_buf
);
18649 return (PARSER_SALT_LENGTH
);
18652 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18664 esalt_len
= 1 + nonce_len
+ 1 + 32;
18666 if (esalt_len
> max_esalt_len
)
18668 myfree (temp_input_buf
);
18670 return (PARSER_SALT_LENGTH
);
18673 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18681 // add 0x80 to esalt
18683 esalt_buf_ptr
[esalt_len
] = 0x80;
18685 sip
->esalt_len
= esalt_len
;
18691 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18693 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18695 uint max_salt_len
= 119;
18697 if (salt_len
> max_salt_len
)
18699 myfree (temp_input_buf
);
18701 return (PARSER_SALT_LENGTH
);
18704 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18706 sip
->salt_len
= salt_len
;
18709 * fake salt (for sorting)
18712 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18716 uint fake_salt_len
= salt_len
;
18718 if (fake_salt_len
> max_salt_len
)
18720 fake_salt_len
= max_salt_len
;
18723 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18725 salt
->salt_len
= fake_salt_len
;
18731 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18732 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18733 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18734 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18736 digest
[0] = byte_swap_32 (digest
[0]);
18737 digest
[1] = byte_swap_32 (digest
[1]);
18738 digest
[2] = byte_swap_32 (digest
[2]);
18739 digest
[3] = byte_swap_32 (digest
[3]);
18741 myfree (temp_input_buf
);
18743 return (PARSER_OK
);
18746 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18748 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18750 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18752 u32
*digest
= (u32
*) hash_buf
->digest
;
18754 salt_t
*salt
= hash_buf
->salt
;
18758 char *digest_pos
= input_buf
;
18760 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18767 char *salt_buf
= input_buf
+ 8 + 1;
18771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18773 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18775 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18777 salt
->salt_len
= salt_len
;
18779 return (PARSER_OK
);
18782 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18784 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18786 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18788 u32
*digest
= (u32
*) hash_buf
->digest
;
18790 salt_t
*salt
= hash_buf
->salt
;
18792 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18798 char *p_buf_pos
= input_buf
+ 4;
18800 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18802 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18804 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18806 NumCyclesPower_pos
++;
18808 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18810 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18812 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18816 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18818 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18820 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18824 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18826 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18828 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18832 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18834 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18836 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18840 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18842 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18844 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18848 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18850 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18852 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18856 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18858 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18860 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18864 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18866 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18868 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18872 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;
18874 const uint iter
= atoi (NumCyclesPower_pos
);
18875 const uint crc
= atoi (crc_buf_pos
);
18876 const uint p_buf
= atoi (p_buf_pos
);
18877 const uint salt_len
= atoi (salt_len_pos
);
18878 const uint iv_len
= atoi (iv_len_pos
);
18879 const uint unpack_size
= atoi (unpack_size_pos
);
18880 const uint data_len
= atoi (data_len_pos
);
18886 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18887 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18889 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18891 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18893 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18899 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18900 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18901 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18902 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18904 seven_zip
->iv_len
= iv_len
;
18906 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18908 seven_zip
->salt_len
= 0;
18910 seven_zip
->crc
= crc
;
18912 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18914 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18916 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18919 seven_zip
->data_len
= data_len
;
18921 seven_zip
->unpack_size
= unpack_size
;
18925 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18926 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18927 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18928 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18930 salt
->salt_len
= 16;
18932 salt
->salt_sign
[0] = iter
;
18934 salt
->salt_iter
= 1 << iter
;
18945 return (PARSER_OK
);
18948 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18950 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18952 u32
*digest
= (u32
*) hash_buf
->digest
;
18954 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18955 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18956 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18957 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18958 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18959 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18960 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18961 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18963 digest
[0] = byte_swap_32 (digest
[0]);
18964 digest
[1] = byte_swap_32 (digest
[1]);
18965 digest
[2] = byte_swap_32 (digest
[2]);
18966 digest
[3] = byte_swap_32 (digest
[3]);
18967 digest
[4] = byte_swap_32 (digest
[4]);
18968 digest
[5] = byte_swap_32 (digest
[5]);
18969 digest
[6] = byte_swap_32 (digest
[6]);
18970 digest
[7] = byte_swap_32 (digest
[7]);
18972 return (PARSER_OK
);
18975 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18977 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18979 u32
*digest
= (u32
*) hash_buf
->digest
;
18981 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18982 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18983 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18984 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18985 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18986 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18987 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18988 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18989 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18990 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18991 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18992 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18993 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18994 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18995 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18996 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18998 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18999 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19000 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19001 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19002 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19003 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19004 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19005 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19006 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19007 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19008 digest
[10] = byte_swap_32 (digest
[10]);
19009 digest
[11] = byte_swap_32 (digest
[11]);
19010 digest
[12] = byte_swap_32 (digest
[12]);
19011 digest
[13] = byte_swap_32 (digest
[13]);
19012 digest
[14] = byte_swap_32 (digest
[14]);
19013 digest
[15] = byte_swap_32 (digest
[15]);
19015 return (PARSER_OK
);
19018 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19020 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19022 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19024 u32
*digest
= (u32
*) hash_buf
->digest
;
19026 salt_t
*salt
= hash_buf
->salt
;
19028 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19036 char *iter_pos
= input_buf
+ 4;
19038 u32 iter
= atoi (iter_pos
);
19040 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19041 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19043 // first is *raw* salt
19045 char *salt_pos
= strchr (iter_pos
, ':');
19047 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19051 char *hash_pos
= strchr (salt_pos
, ':');
19053 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19055 u32 salt_len
= hash_pos
- salt_pos
;
19057 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19061 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19063 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19067 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19073 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19074 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19076 salt
->salt_len
= salt_len
;
19077 salt
->salt_iter
= iter
- 1;
19081 u8 tmp_buf
[100] = { 0 };
19083 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19085 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19087 memcpy (digest
, tmp_buf
, 16);
19089 // add some stuff to normal salt to make sorted happy
19091 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19092 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19093 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19094 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19095 salt
->salt_buf
[4] = salt
->salt_iter
;
19097 return (PARSER_OK
);
19100 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19102 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19104 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19106 u32
*digest
= (u32
*) hash_buf
->digest
;
19108 salt_t
*salt
= hash_buf
->salt
;
19110 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19118 char *iter_pos
= input_buf
+ 5;
19120 u32 iter
= atoi (iter_pos
);
19122 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19123 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19125 // first is *raw* salt
19127 char *salt_pos
= strchr (iter_pos
, ':');
19129 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19133 char *hash_pos
= strchr (salt_pos
, ':');
19135 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19137 u32 salt_len
= hash_pos
- salt_pos
;
19139 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19143 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19145 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19149 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19151 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19155 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19156 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19158 salt
->salt_len
= salt_len
;
19159 salt
->salt_iter
= iter
- 1;
19163 u8 tmp_buf
[100] = { 0 };
19165 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19167 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19169 memcpy (digest
, tmp_buf
, 16);
19171 digest
[0] = byte_swap_32 (digest
[0]);
19172 digest
[1] = byte_swap_32 (digest
[1]);
19173 digest
[2] = byte_swap_32 (digest
[2]);
19174 digest
[3] = byte_swap_32 (digest
[3]);
19176 // add some stuff to normal salt to make sorted happy
19178 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19179 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19180 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19181 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19182 salt
->salt_buf
[4] = salt
->salt_iter
;
19184 return (PARSER_OK
);
19187 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19189 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19191 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19193 u64
*digest
= (u64
*) hash_buf
->digest
;
19195 salt_t
*salt
= hash_buf
->salt
;
19197 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19205 char *iter_pos
= input_buf
+ 7;
19207 u32 iter
= atoi (iter_pos
);
19209 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19210 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19212 // first is *raw* salt
19214 char *salt_pos
= strchr (iter_pos
, ':');
19216 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19220 char *hash_pos
= strchr (salt_pos
, ':');
19222 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19224 u32 salt_len
= hash_pos
- salt_pos
;
19226 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19230 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19232 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19236 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19242 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19243 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19245 salt
->salt_len
= salt_len
;
19246 salt
->salt_iter
= iter
- 1;
19250 u8 tmp_buf
[100] = { 0 };
19252 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19254 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19256 memcpy (digest
, tmp_buf
, 64);
19258 digest
[0] = byte_swap_64 (digest
[0]);
19259 digest
[1] = byte_swap_64 (digest
[1]);
19260 digest
[2] = byte_swap_64 (digest
[2]);
19261 digest
[3] = byte_swap_64 (digest
[3]);
19262 digest
[4] = byte_swap_64 (digest
[4]);
19263 digest
[5] = byte_swap_64 (digest
[5]);
19264 digest
[6] = byte_swap_64 (digest
[6]);
19265 digest
[7] = byte_swap_64 (digest
[7]);
19267 // add some stuff to normal salt to make sorted happy
19269 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19270 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19271 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19272 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19273 salt
->salt_buf
[4] = salt
->salt_iter
;
19275 return (PARSER_OK
);
19278 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19280 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19282 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19284 uint
*digest
= (uint
*) hash_buf
->digest
;
19286 salt_t
*salt
= hash_buf
->salt
;
19292 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19294 char *hash_pos
= strchr (salt_pos
, '$');
19296 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19298 u32 salt_len
= hash_pos
- salt_pos
;
19300 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19304 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19306 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19310 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19311 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19329 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19330 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19332 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19333 salt
->salt_len
= 8;
19335 return (PARSER_OK
);
19338 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19340 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19342 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19344 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19346 if (c19
& 3) return (PARSER_HASH_VALUE
);
19348 salt_t
*salt
= hash_buf
->salt
;
19350 u32
*digest
= (u32
*) hash_buf
->digest
;
19354 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19355 | itoa64_to_int (input_buf
[2]) << 6
19356 | itoa64_to_int (input_buf
[3]) << 12
19357 | itoa64_to_int (input_buf
[4]) << 18;
19361 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19362 | itoa64_to_int (input_buf
[6]) << 6
19363 | itoa64_to_int (input_buf
[7]) << 12
19364 | itoa64_to_int (input_buf
[8]) << 18;
19366 salt
->salt_len
= 4;
19368 u8 tmp_buf
[100] = { 0 };
19370 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19372 memcpy (digest
, tmp_buf
, 8);
19376 IP (digest
[0], digest
[1], tt
);
19378 digest
[0] = rotr32 (digest
[0], 31);
19379 digest
[1] = rotr32 (digest
[1], 31);
19383 return (PARSER_OK
);
19386 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19388 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19390 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19392 u32
*digest
= (u32
*) hash_buf
->digest
;
19394 salt_t
*salt
= hash_buf
->salt
;
19400 char *type_pos
= input_buf
+ 6 + 1;
19402 char *salt_pos
= strchr (type_pos
, '*');
19404 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19406 u32 type_len
= salt_pos
- type_pos
;
19408 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19412 char *crypted_pos
= strchr (salt_pos
, '*');
19414 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19416 u32 salt_len
= crypted_pos
- salt_pos
;
19418 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19422 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19424 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19430 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19431 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19433 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19434 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19436 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19437 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19438 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19439 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19441 salt
->salt_len
= 24;
19442 salt
->salt_iter
= ROUNDS_RAR3
;
19444 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19445 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19447 digest
[0] = 0xc43d7b00;
19448 digest
[1] = 0x40070000;
19452 return (PARSER_OK
);
19455 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19457 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19459 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19461 u32
*digest
= (u32
*) hash_buf
->digest
;
19463 salt_t
*salt
= hash_buf
->salt
;
19465 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19471 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19473 char *param1_pos
= strchr (param0_pos
, '$');
19475 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19477 u32 param0_len
= param1_pos
- param0_pos
;
19481 char *param2_pos
= strchr (param1_pos
, '$');
19483 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19485 u32 param1_len
= param2_pos
- param1_pos
;
19489 char *param3_pos
= strchr (param2_pos
, '$');
19491 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19493 u32 param2_len
= param3_pos
- param2_pos
;
19497 char *param4_pos
= strchr (param3_pos
, '$');
19499 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19501 u32 param3_len
= param4_pos
- param3_pos
;
19505 char *param5_pos
= strchr (param4_pos
, '$');
19507 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19509 u32 param4_len
= param5_pos
- param4_pos
;
19513 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19515 char *salt_buf
= param1_pos
;
19516 char *iv
= param3_pos
;
19517 char *pswcheck
= param5_pos
;
19519 const uint salt_len
= atoi (param0_pos
);
19520 const uint iterations
= atoi (param2_pos
);
19521 const uint pswcheck_len
= atoi (param4_pos
);
19527 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19528 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19529 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19531 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19532 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19533 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19539 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19540 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19541 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19542 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19544 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19545 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19546 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19547 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19549 salt
->salt_len
= 16;
19551 salt
->salt_sign
[0] = iterations
;
19553 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19559 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19560 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19564 return (PARSER_OK
);
19567 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19569 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19571 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19573 u32
*digest
= (u32
*) hash_buf
->digest
;
19575 salt_t
*salt
= hash_buf
->salt
;
19577 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19584 char *account_pos
= input_buf
+ 11 + 1;
19590 if (account_pos
[0] == '*')
19594 data_pos
= strchr (account_pos
, '*');
19599 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19601 uint account_len
= data_pos
- account_pos
+ 1;
19603 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19608 data_len
= input_len
- 11 - 1 - account_len
- 2;
19610 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19614 /* assume $krb5tgs$23$checksum$edata2 */
19615 data_pos
= account_pos
;
19617 memcpy (krb5tgs
->account_info
, "**", 3);
19619 data_len
= input_len
- 11 - 1 - 1;
19622 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19624 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19626 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19628 const char p0
= data_pos
[i
+ 0];
19629 const char p1
= data_pos
[i
+ 1];
19631 *checksum_ptr
++ = hex_convert (p1
) << 0
19632 | hex_convert (p0
) << 4;
19635 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19637 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19640 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19642 const char p0
= data_pos
[i
+ 0];
19643 const char p1
= data_pos
[i
+ 1];
19644 *edata_ptr
++ = hex_convert (p1
) << 0
19645 | hex_convert (p0
) << 4;
19648 /* this is needed for hmac_md5 */
19649 *edata_ptr
++ = 0x80;
19651 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19652 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19653 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19654 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19656 salt
->salt_len
= 32;
19658 digest
[0] = krb5tgs
->checksum
[0];
19659 digest
[1] = krb5tgs
->checksum
[1];
19660 digest
[2] = krb5tgs
->checksum
[2];
19661 digest
[3] = krb5tgs
->checksum
[3];
19663 return (PARSER_OK
);
19666 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19668 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19670 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19672 u32
*digest
= (u32
*) hash_buf
->digest
;
19674 salt_t
*salt
= hash_buf
->salt
;
19681 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19685 char *wrapped_key_pos
;
19689 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19691 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19693 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19695 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19700 data_pos
= salt_pos
;
19702 wrapped_key_pos
= strchr (salt_pos
, '*');
19704 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19706 uint salt_len
= wrapped_key_pos
- salt_pos
;
19708 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19713 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19715 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19717 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19718 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19719 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19720 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19724 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19725 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19726 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19727 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19728 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19729 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19731 salt
->salt_len
= 40;
19733 digest
[0] = salt
->salt_buf
[0];
19734 digest
[1] = salt
->salt_buf
[1];
19735 digest
[2] = salt
->salt_buf
[2];
19736 digest
[3] = salt
->salt_buf
[3];
19738 return (PARSER_OK
);
19741 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19743 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19745 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19747 u32
*digest
= (u32
*) hash_buf
->digest
;
19749 salt_t
*salt
= hash_buf
->salt
;
19751 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19761 char *algorithm_pos
;
19763 char *final_random_seed_pos
;
19764 u32 final_random_seed_len
;
19766 char *transf_random_seed_pos
;
19767 u32 transf_random_seed_len
;
19772 /* default is no keyfile provided */
19773 char *keyfile_len_pos
;
19774 u32 keyfile_len
= 0;
19775 u32 is_keyfile_present
= 0;
19776 char *keyfile_inline_pos
;
19779 /* specific to version 1 */
19780 char *contents_len_pos
;
19782 char *contents_pos
;
19784 /* specific to version 2 */
19785 char *expected_bytes_pos
;
19786 u32 expected_bytes_len
;
19788 char *contents_hash_pos
;
19789 u32 contents_hash_len
;
19791 version_pos
= input_buf
+ 8 + 1 + 1;
19793 keepass
->version
= atoi (version_pos
);
19795 rounds_pos
= strchr (version_pos
, '*');
19797 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19801 salt
->salt_iter
= (atoi (rounds_pos
));
19803 algorithm_pos
= strchr (rounds_pos
, '*');
19805 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19809 keepass
->algorithm
= atoi (algorithm_pos
);
19811 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19813 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19815 final_random_seed_pos
++;
19817 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19818 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19819 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19820 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19822 if (keepass
->version
== 2)
19824 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19825 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19826 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19827 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19830 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19832 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19834 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19836 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19837 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19839 transf_random_seed_pos
++;
19841 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19842 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19843 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19844 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19845 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19846 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19847 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19848 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19850 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19852 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19854 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19856 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19860 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19861 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19862 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19863 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19865 if (keepass
->version
== 1)
19867 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19869 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19871 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19873 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19875 contents_hash_pos
++;
19877 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19878 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19879 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19880 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19881 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19882 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19883 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19884 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19886 /* get length of contents following */
19887 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19889 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19891 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19893 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19897 u32 inline_flag
= atoi (inline_flag_pos
);
19899 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19901 contents_len_pos
= strchr (inline_flag_pos
, '*');
19903 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19905 contents_len_pos
++;
19907 contents_len
= atoi (contents_len_pos
);
19909 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19911 contents_pos
= strchr (contents_len_pos
, '*');
19913 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19919 keepass
->contents_len
= contents_len
;
19921 contents_len
= contents_len
/ 4;
19923 keyfile_inline_pos
= strchr (contents_pos
, '*');
19925 u32 real_contents_len
;
19927 if (keyfile_inline_pos
== NULL
)
19928 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19931 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19932 keyfile_inline_pos
++;
19933 is_keyfile_present
= 1;
19936 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19938 for (i
= 0; i
< contents_len
; i
++)
19939 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19941 else if (keepass
->version
== 2)
19943 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19945 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19947 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19949 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19951 expected_bytes_pos
++;
19953 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19954 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19955 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19956 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19957 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19958 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19959 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19960 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19962 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19964 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19966 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19968 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19970 contents_hash_pos
++;
19972 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19973 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19974 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19975 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19976 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19977 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19978 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19979 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19981 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19983 if (keyfile_inline_pos
== NULL
)
19984 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19987 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19988 keyfile_inline_pos
++;
19989 is_keyfile_present
= 1;
19991 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19994 if (is_keyfile_present
!= 0)
19996 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20000 keyfile_len
= atoi (keyfile_len_pos
);
20002 keepass
->keyfile_len
= keyfile_len
;
20004 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20006 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20008 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20012 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20014 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20016 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20017 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20018 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20019 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20020 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20021 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20022 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20023 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20026 digest
[0] = keepass
->enc_iv
[0];
20027 digest
[1] = keepass
->enc_iv
[1];
20028 digest
[2] = keepass
->enc_iv
[2];
20029 digest
[3] = keepass
->enc_iv
[3];
20031 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20032 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20033 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20034 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20035 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20036 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20037 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20038 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20040 return (PARSER_OK
);
20043 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20045 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20047 u32
*digest
= (u32
*) hash_buf
->digest
;
20049 salt_t
*salt
= hash_buf
->salt
;
20051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20055 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20056 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20057 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20058 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20060 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20062 uint salt_len
= input_len
- 64 - 1;
20064 char *salt_buf
= input_buf
+ 64 + 1;
20066 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20070 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20072 salt
->salt_len
= salt_len
;
20075 * we can precompute the first sha256 transform
20078 uint w
[16] = { 0 };
20080 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20081 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20082 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20083 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20084 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20085 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20086 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20087 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20088 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20089 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20090 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20091 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20092 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20093 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20094 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20095 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20097 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20099 sha256_64 (w
, pc256
);
20101 salt
->salt_buf_pc
[0] = pc256
[0];
20102 salt
->salt_buf_pc
[1] = pc256
[1];
20103 salt
->salt_buf_pc
[2] = pc256
[2];
20104 salt
->salt_buf_pc
[3] = pc256
[3];
20105 salt
->salt_buf_pc
[4] = pc256
[4];
20106 salt
->salt_buf_pc
[5] = pc256
[5];
20107 salt
->salt_buf_pc
[6] = pc256
[6];
20108 salt
->salt_buf_pc
[7] = pc256
[7];
20110 digest
[0] -= pc256
[0];
20111 digest
[1] -= pc256
[1];
20112 digest
[2] -= pc256
[2];
20113 digest
[3] -= pc256
[3];
20114 digest
[4] -= pc256
[4];
20115 digest
[5] -= pc256
[5];
20116 digest
[6] -= pc256
[6];
20117 digest
[7] -= pc256
[7];
20119 return (PARSER_OK
);
20122 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20124 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20126 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20128 u32
*digest
= (u32
*) hash_buf
->digest
;
20130 salt_t
*salt
= hash_buf
->salt
;
20136 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20138 char *data_buf_pos
= strchr (data_len_pos
, '$');
20140 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20142 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20144 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20145 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20149 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20151 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20153 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20155 u32 data_len
= atoi (data_len_pos
);
20157 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20163 char *salt_pos
= data_buf_pos
;
20165 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20166 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20167 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20168 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20170 // this is actually the CT, which is also the hash later (if matched)
20172 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20173 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20174 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20175 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20177 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20179 salt
->salt_iter
= 10 - 1;
20185 digest
[0] = salt
->salt_buf
[4];
20186 digest
[1] = salt
->salt_buf
[5];
20187 digest
[2] = salt
->salt_buf
[6];
20188 digest
[3] = salt
->salt_buf
[7];
20190 return (PARSER_OK
);
20193 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20195 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20197 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20199 u32
*digest
= (u32
*) hash_buf
->digest
;
20201 salt_t
*salt
= hash_buf
->salt
;
20207 char *salt_pos
= input_buf
+ 11 + 1;
20209 char *iter_pos
= strchr (salt_pos
, ',');
20211 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20213 u32 salt_len
= iter_pos
- salt_pos
;
20215 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20219 char *hash_pos
= strchr (iter_pos
, ',');
20221 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20223 u32 iter_len
= hash_pos
- iter_pos
;
20225 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20229 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20231 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20237 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20238 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20239 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20240 salt
->salt_buf
[3] = 0x00018000;
20242 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20243 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20244 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20245 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20247 salt
->salt_len
= salt_len
/ 2;
20249 salt
->salt_iter
= atoi (iter_pos
) - 1;
20255 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20256 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20257 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20258 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20259 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20260 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20261 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20262 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20264 return (PARSER_OK
);
20267 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20269 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20271 u32
*digest
= (u32
*) hash_buf
->digest
;
20273 salt_t
*salt
= hash_buf
->salt
;
20279 char *hash_pos
= input_buf
+ 64;
20280 char *salt1_pos
= input_buf
+ 128;
20281 char *salt2_pos
= input_buf
;
20287 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20288 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20289 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20290 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20292 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20293 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20294 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20295 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20297 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20298 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20299 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20300 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20302 salt
->salt_len
= 48;
20304 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20310 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20311 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20312 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20313 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20314 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20315 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20316 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20317 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20319 return (PARSER_OK
);
20322 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20324 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20326 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20327 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20329 u32
*digest
= (u32
*) hash_buf
->digest
;
20331 salt_t
*salt
= hash_buf
->salt
;
20333 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20339 char *param0_pos
= input_buf
+ 6 + 1;
20341 char *param1_pos
= strchr (param0_pos
, '*');
20343 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20345 u32 param0_len
= param1_pos
- param0_pos
;
20349 char *param2_pos
= strchr (param1_pos
, '*');
20351 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20353 u32 param1_len
= param2_pos
- param1_pos
;
20357 char *param3_pos
= strchr (param2_pos
, '*');
20359 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20361 u32 param2_len
= param3_pos
- param2_pos
;
20365 char *param4_pos
= strchr (param3_pos
, '*');
20367 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20369 u32 param3_len
= param4_pos
- param3_pos
;
20373 char *param5_pos
= strchr (param4_pos
, '*');
20375 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20377 u32 param4_len
= param5_pos
- param4_pos
;
20381 char *param6_pos
= strchr (param5_pos
, '*');
20383 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20385 u32 param5_len
= param6_pos
- param5_pos
;
20389 char *param7_pos
= strchr (param6_pos
, '*');
20391 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20393 u32 param6_len
= param7_pos
- param6_pos
;
20397 char *param8_pos
= strchr (param7_pos
, '*');
20399 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20401 u32 param7_len
= param8_pos
- param7_pos
;
20405 const uint type
= atoi (param0_pos
);
20406 const uint mode
= atoi (param1_pos
);
20407 const uint magic
= atoi (param2_pos
);
20409 char *salt_buf
= param3_pos
;
20411 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20413 const uint compress_length
= atoi (param5_pos
);
20415 char *data_buf
= param6_pos
;
20416 char *auth
= param7_pos
;
20422 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20424 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20426 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20428 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20430 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20432 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20434 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20436 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20438 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20440 if (type
!= 0) return (PARSER_SALT_VALUE
);
20442 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20444 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20446 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20454 zip2
->magic
= magic
;
20458 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20459 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20460 zip2
->salt_buf
[2] = 0;
20461 zip2
->salt_buf
[3] = 0;
20463 zip2
->salt_len
= 8;
20465 else if (mode
== 2)
20467 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20468 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20469 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20470 zip2
->salt_buf
[3] = 0;
20472 zip2
->salt_len
= 12;
20474 else if (mode
== 3)
20476 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20477 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20478 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20479 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20481 zip2
->salt_len
= 16;
20484 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20485 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20486 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20487 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20489 zip2
->verify_bytes
= verify_bytes
;
20491 zip2
->compress_length
= compress_length
;
20493 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20495 for (uint i
= 0; i
< param6_len
; i
+= 2)
20497 const char p0
= data_buf
[i
+ 0];
20498 const char p1
= data_buf
[i
+ 1];
20500 *data_buf_ptr
++ = hex_convert (p1
) << 0
20501 | hex_convert (p0
) << 4;
20506 *data_buf_ptr
= 0x80;
20508 char *auth_ptr
= (char *) zip2
->auth_buf
;
20510 for (uint i
= 0; i
< param7_len
; i
+= 2)
20512 const char p0
= auth
[i
+ 0];
20513 const char p1
= auth
[i
+ 1];
20515 *auth_ptr
++ = hex_convert (p1
) << 0
20516 | hex_convert (p0
) << 4;
20525 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20526 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20527 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20528 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20529 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20530 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20531 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20532 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20534 salt
->salt_len
= 32;
20536 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20539 * digest buf (fake)
20542 digest
[0] = zip2
->auth_buf
[0];
20543 digest
[1] = zip2
->auth_buf
[1];
20544 digest
[2] = zip2
->auth_buf
[2];
20545 digest
[3] = zip2
->auth_buf
[3];
20547 return (PARSER_OK
);
20551 * parallel running threads
20556 BOOL WINAPI
sigHandler_default (DWORD sig
)
20560 case CTRL_CLOSE_EVENT
:
20563 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20564 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20565 * function otherwise it is too late (e.g. after returning from this function)
20570 SetConsoleCtrlHandler (NULL
, TRUE
);
20577 case CTRL_LOGOFF_EVENT
:
20578 case CTRL_SHUTDOWN_EVENT
:
20582 SetConsoleCtrlHandler (NULL
, TRUE
);
20590 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20594 case CTRL_CLOSE_EVENT
:
20598 SetConsoleCtrlHandler (NULL
, TRUE
);
20605 case CTRL_LOGOFF_EVENT
:
20606 case CTRL_SHUTDOWN_EVENT
:
20610 SetConsoleCtrlHandler (NULL
, TRUE
);
20618 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20620 if (callback
== NULL
)
20622 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20626 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20632 void sigHandler_default (int sig
)
20636 signal (sig
, NULL
);
20639 void sigHandler_benchmark (int sig
)
20643 signal (sig
, NULL
);
20646 void hc_signal (void (callback
) (int))
20648 if (callback
== NULL
) callback
= SIG_DFL
;
20650 signal (SIGINT
, callback
);
20651 signal (SIGTERM
, callback
);
20652 signal (SIGABRT
, callback
);
20657 void status_display ();
20659 void *thread_keypress (void *p
)
20661 int benchmark
= *((int *) p
);
20663 uint quiet
= data
.quiet
;
20667 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20669 int ch
= tty_getchar();
20671 if (ch
== -1) break;
20673 if (ch
== 0) continue;
20675 //https://github.com/hashcat/hashcat/issues/302
20680 hc_thread_mutex_lock (mux_display
);
20696 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20697 if (quiet
== 0) fflush (stdout
);
20709 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20710 if (quiet
== 0) fflush (stdout
);
20722 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20723 if (quiet
== 0) fflush (stdout
);
20735 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20736 if (quiet
== 0) fflush (stdout
);
20744 if (benchmark
== 1) break;
20746 stop_at_checkpoint ();
20750 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20751 if (quiet
== 0) fflush (stdout
);
20759 if (benchmark
== 1)
20771 //https://github.com/hashcat/hashcat/issues/302
20776 hc_thread_mutex_unlock (mux_display
);
20788 bool class_num (const u8 c
)
20790 return ((c
>= '0') && (c
<= '9'));
20793 bool class_lower (const u8 c
)
20795 return ((c
>= 'a') && (c
<= 'z'));
20798 bool class_upper (const u8 c
)
20800 return ((c
>= 'A') && (c
<= 'Z'));
20803 bool class_alpha (const u8 c
)
20805 return (class_lower (c
) || class_upper (c
));
20808 int conv_ctoi (const u8 c
)
20814 else if (class_upper (c
))
20816 return c
- 'A' + 10;
20822 int conv_itoc (const u8 c
)
20830 return c
+ 'A' - 10;
20840 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20841 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20842 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20843 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20844 #define MAX_KERNEL_RULES 255
20845 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20846 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20847 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20849 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20850 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20851 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20852 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20854 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20859 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20861 switch (rule_buf
[rule_pos
])
20867 case RULE_OP_MANGLE_NOOP
:
20868 SET_NAME (rule
, rule_buf
[rule_pos
]);
20871 case RULE_OP_MANGLE_LREST
:
20872 SET_NAME (rule
, rule_buf
[rule_pos
]);
20875 case RULE_OP_MANGLE_UREST
:
20876 SET_NAME (rule
, rule_buf
[rule_pos
]);
20879 case RULE_OP_MANGLE_LREST_UFIRST
:
20880 SET_NAME (rule
, rule_buf
[rule_pos
]);
20883 case RULE_OP_MANGLE_UREST_LFIRST
:
20884 SET_NAME (rule
, rule_buf
[rule_pos
]);
20887 case RULE_OP_MANGLE_TREST
:
20888 SET_NAME (rule
, rule_buf
[rule_pos
]);
20891 case RULE_OP_MANGLE_TOGGLE_AT
:
20892 SET_NAME (rule
, rule_buf
[rule_pos
]);
20893 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20896 case RULE_OP_MANGLE_REVERSE
:
20897 SET_NAME (rule
, rule_buf
[rule_pos
]);
20900 case RULE_OP_MANGLE_DUPEWORD
:
20901 SET_NAME (rule
, rule_buf
[rule_pos
]);
20904 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20905 SET_NAME (rule
, rule_buf
[rule_pos
]);
20906 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20909 case RULE_OP_MANGLE_REFLECT
:
20910 SET_NAME (rule
, rule_buf
[rule_pos
]);
20913 case RULE_OP_MANGLE_ROTATE_LEFT
:
20914 SET_NAME (rule
, rule_buf
[rule_pos
]);
20917 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20918 SET_NAME (rule
, rule_buf
[rule_pos
]);
20921 case RULE_OP_MANGLE_APPEND
:
20922 SET_NAME (rule
, rule_buf
[rule_pos
]);
20923 SET_P0 (rule
, rule_buf
[rule_pos
]);
20926 case RULE_OP_MANGLE_PREPEND
:
20927 SET_NAME (rule
, rule_buf
[rule_pos
]);
20928 SET_P0 (rule
, rule_buf
[rule_pos
]);
20931 case RULE_OP_MANGLE_DELETE_FIRST
:
20932 SET_NAME (rule
, rule_buf
[rule_pos
]);
20935 case RULE_OP_MANGLE_DELETE_LAST
:
20936 SET_NAME (rule
, rule_buf
[rule_pos
]);
20939 case RULE_OP_MANGLE_DELETE_AT
:
20940 SET_NAME (rule
, rule_buf
[rule_pos
]);
20941 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20944 case RULE_OP_MANGLE_EXTRACT
:
20945 SET_NAME (rule
, rule_buf
[rule_pos
]);
20946 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20947 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20950 case RULE_OP_MANGLE_OMIT
:
20951 SET_NAME (rule
, rule_buf
[rule_pos
]);
20952 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20953 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20956 case RULE_OP_MANGLE_INSERT
:
20957 SET_NAME (rule
, rule_buf
[rule_pos
]);
20958 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20959 SET_P1 (rule
, rule_buf
[rule_pos
]);
20962 case RULE_OP_MANGLE_OVERSTRIKE
:
20963 SET_NAME (rule
, rule_buf
[rule_pos
]);
20964 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20965 SET_P1 (rule
, rule_buf
[rule_pos
]);
20968 case RULE_OP_MANGLE_TRUNCATE_AT
:
20969 SET_NAME (rule
, rule_buf
[rule_pos
]);
20970 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20973 case RULE_OP_MANGLE_REPLACE
:
20974 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 SET_P0 (rule
, rule_buf
[rule_pos
]);
20976 SET_P1 (rule
, rule_buf
[rule_pos
]);
20979 case RULE_OP_MANGLE_PURGECHAR
:
20983 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20987 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20988 SET_NAME (rule
, rule_buf
[rule_pos
]);
20989 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20992 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20993 SET_NAME (rule
, rule_buf
[rule_pos
]);
20994 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20997 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20998 SET_NAME (rule
, rule_buf
[rule_pos
]);
21001 case RULE_OP_MANGLE_SWITCH_FIRST
:
21002 SET_NAME (rule
, rule_buf
[rule_pos
]);
21005 case RULE_OP_MANGLE_SWITCH_LAST
:
21006 SET_NAME (rule
, rule_buf
[rule_pos
]);
21009 case RULE_OP_MANGLE_SWITCH_AT
:
21010 SET_NAME (rule
, rule_buf
[rule_pos
]);
21011 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21012 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21015 case RULE_OP_MANGLE_CHR_SHIFTL
:
21016 SET_NAME (rule
, rule_buf
[rule_pos
]);
21017 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21020 case RULE_OP_MANGLE_CHR_SHIFTR
:
21021 SET_NAME (rule
, rule_buf
[rule_pos
]);
21022 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21025 case RULE_OP_MANGLE_CHR_INCR
:
21026 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21030 case RULE_OP_MANGLE_CHR_DECR
:
21031 SET_NAME (rule
, rule_buf
[rule_pos
]);
21032 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21035 case RULE_OP_MANGLE_REPLACE_NP1
:
21036 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21040 case RULE_OP_MANGLE_REPLACE_NM1
:
21041 SET_NAME (rule
, rule_buf
[rule_pos
]);
21042 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21045 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21046 SET_NAME (rule
, rule_buf
[rule_pos
]);
21047 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21052 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21055 case RULE_OP_MANGLE_TITLE
:
21056 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 if (rule_pos
< rule_len
) return (-1);
21070 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21074 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21078 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21082 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21086 case RULE_OP_MANGLE_NOOP
:
21087 rule_buf
[rule_pos
] = rule_cmd
;
21090 case RULE_OP_MANGLE_LREST
:
21091 rule_buf
[rule_pos
] = rule_cmd
;
21094 case RULE_OP_MANGLE_UREST
:
21095 rule_buf
[rule_pos
] = rule_cmd
;
21098 case RULE_OP_MANGLE_LREST_UFIRST
:
21099 rule_buf
[rule_pos
] = rule_cmd
;
21102 case RULE_OP_MANGLE_UREST_LFIRST
:
21103 rule_buf
[rule_pos
] = rule_cmd
;
21106 case RULE_OP_MANGLE_TREST
:
21107 rule_buf
[rule_pos
] = rule_cmd
;
21110 case RULE_OP_MANGLE_TOGGLE_AT
:
21111 rule_buf
[rule_pos
] = rule_cmd
;
21112 GET_P0_CONV (rule
);
21115 case RULE_OP_MANGLE_REVERSE
:
21116 rule_buf
[rule_pos
] = rule_cmd
;
21119 case RULE_OP_MANGLE_DUPEWORD
:
21120 rule_buf
[rule_pos
] = rule_cmd
;
21123 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21124 rule_buf
[rule_pos
] = rule_cmd
;
21125 GET_P0_CONV (rule
);
21128 case RULE_OP_MANGLE_REFLECT
:
21129 rule_buf
[rule_pos
] = rule_cmd
;
21132 case RULE_OP_MANGLE_ROTATE_LEFT
:
21133 rule_buf
[rule_pos
] = rule_cmd
;
21136 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21137 rule_buf
[rule_pos
] = rule_cmd
;
21140 case RULE_OP_MANGLE_APPEND
:
21141 rule_buf
[rule_pos
] = rule_cmd
;
21145 case RULE_OP_MANGLE_PREPEND
:
21146 rule_buf
[rule_pos
] = rule_cmd
;
21150 case RULE_OP_MANGLE_DELETE_FIRST
:
21151 rule_buf
[rule_pos
] = rule_cmd
;
21154 case RULE_OP_MANGLE_DELETE_LAST
:
21155 rule_buf
[rule_pos
] = rule_cmd
;
21158 case RULE_OP_MANGLE_DELETE_AT
:
21159 rule_buf
[rule_pos
] = rule_cmd
;
21160 GET_P0_CONV (rule
);
21163 case RULE_OP_MANGLE_EXTRACT
:
21164 rule_buf
[rule_pos
] = rule_cmd
;
21165 GET_P0_CONV (rule
);
21166 GET_P1_CONV (rule
);
21169 case RULE_OP_MANGLE_OMIT
:
21170 rule_buf
[rule_pos
] = rule_cmd
;
21171 GET_P0_CONV (rule
);
21172 GET_P1_CONV (rule
);
21175 case RULE_OP_MANGLE_INSERT
:
21176 rule_buf
[rule_pos
] = rule_cmd
;
21177 GET_P0_CONV (rule
);
21181 case RULE_OP_MANGLE_OVERSTRIKE
:
21182 rule_buf
[rule_pos
] = rule_cmd
;
21183 GET_P0_CONV (rule
);
21187 case RULE_OP_MANGLE_TRUNCATE_AT
:
21188 rule_buf
[rule_pos
] = rule_cmd
;
21189 GET_P0_CONV (rule
);
21192 case RULE_OP_MANGLE_REPLACE
:
21193 rule_buf
[rule_pos
] = rule_cmd
;
21198 case RULE_OP_MANGLE_PURGECHAR
:
21202 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21206 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21207 rule_buf
[rule_pos
] = rule_cmd
;
21208 GET_P0_CONV (rule
);
21211 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21212 rule_buf
[rule_pos
] = rule_cmd
;
21213 GET_P0_CONV (rule
);
21216 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21217 rule_buf
[rule_pos
] = rule_cmd
;
21220 case RULE_OP_MANGLE_SWITCH_FIRST
:
21221 rule_buf
[rule_pos
] = rule_cmd
;
21224 case RULE_OP_MANGLE_SWITCH_LAST
:
21225 rule_buf
[rule_pos
] = rule_cmd
;
21228 case RULE_OP_MANGLE_SWITCH_AT
:
21229 rule_buf
[rule_pos
] = rule_cmd
;
21230 GET_P0_CONV (rule
);
21231 GET_P1_CONV (rule
);
21234 case RULE_OP_MANGLE_CHR_SHIFTL
:
21235 rule_buf
[rule_pos
] = rule_cmd
;
21236 GET_P0_CONV (rule
);
21239 case RULE_OP_MANGLE_CHR_SHIFTR
:
21240 rule_buf
[rule_pos
] = rule_cmd
;
21241 GET_P0_CONV (rule
);
21244 case RULE_OP_MANGLE_CHR_INCR
:
21245 rule_buf
[rule_pos
] = rule_cmd
;
21246 GET_P0_CONV (rule
);
21249 case RULE_OP_MANGLE_CHR_DECR
:
21250 rule_buf
[rule_pos
] = rule_cmd
;
21251 GET_P0_CONV (rule
);
21254 case RULE_OP_MANGLE_REPLACE_NP1
:
21255 rule_buf
[rule_pos
] = rule_cmd
;
21256 GET_P0_CONV (rule
);
21259 case RULE_OP_MANGLE_REPLACE_NM1
:
21260 rule_buf
[rule_pos
] = rule_cmd
;
21261 GET_P0_CONV (rule
);
21264 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21265 rule_buf
[rule_pos
] = rule_cmd
;
21266 GET_P0_CONV (rule
);
21269 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21271 GET_P0_CONV (rule
);
21274 case RULE_OP_MANGLE_TITLE
:
21275 rule_buf
[rule_pos
] = rule_cmd
;
21279 return rule_pos
- 1;
21297 * CPU rules : this is from hashcat sources, cpu based rules
21300 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21301 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21303 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21304 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21305 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21307 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21308 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21309 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21311 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21315 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21320 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21324 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21329 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21333 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21338 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21343 for (l
= 0; l
< arr_len
; l
++)
21345 r
= arr_len
- 1 - l
;
21349 MANGLE_SWITCH (arr
, l
, r
);
21355 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21357 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21359 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21361 return (arr_len
* 2);
21364 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21366 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21368 int orig_len
= arr_len
;
21372 for (i
= 0; i
< times
; i
++)
21374 memcpy (&arr
[arr_len
], arr
, orig_len
);
21376 arr_len
+= orig_len
;
21382 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21384 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21386 mangle_double (arr
, arr_len
);
21388 mangle_reverse (arr
+ arr_len
, arr_len
);
21390 return (arr_len
* 2);
21393 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21398 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21400 MANGLE_SWITCH (arr
, l
, r
);
21406 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21411 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21413 MANGLE_SWITCH (arr
, l
, r
);
21419 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21421 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21425 return (arr_len
+ 1);
21428 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21430 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21434 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21436 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21441 return (arr_len
+ 1);
21444 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21446 if (upos
>= arr_len
) return (arr_len
);
21450 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21452 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21455 return (arr_len
- 1);
21458 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21460 if (upos
>= arr_len
) return (arr_len
);
21462 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21466 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21468 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21474 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21476 if (upos
>= arr_len
) return (arr_len
);
21478 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21482 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21484 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21487 return (arr_len
- ulen
);
21490 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21492 if (upos
>= arr_len
) return (arr_len
);
21494 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21498 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21500 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21505 return (arr_len
+ 1);
21508 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
)
21510 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21512 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21514 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21516 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21518 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21520 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21522 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21524 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21526 return (arr_len
+ arr2_cpy
);
21529 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21531 if (upos
>= arr_len
) return (arr_len
);
21538 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21540 if (upos
>= arr_len
) return (arr_len
);
21542 memset (arr
+ upos
, 0, arr_len
- upos
);
21547 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21551 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21553 if (arr
[arr_pos
] != oldc
) continue;
21555 arr
[arr_pos
] = newc
;
21561 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21567 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21569 if (arr
[arr_pos
] == c
) continue;
21571 arr
[ret_len
] = arr
[arr_pos
];
21579 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21581 if (ulen
> arr_len
) return (arr_len
);
21583 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21585 char cs
[100] = { 0 };
21587 memcpy (cs
, arr
, ulen
);
21591 for (i
= 0; i
< ulen
; i
++)
21595 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21601 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21603 if (ulen
> arr_len
) return (arr_len
);
21605 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21607 int upos
= arr_len
- ulen
;
21611 for (i
= 0; i
< ulen
; i
++)
21613 char c
= arr
[upos
+ i
];
21615 arr_len
= mangle_append (arr
, arr_len
, c
);
21621 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21623 if ( arr_len
== 0) return (arr_len
);
21624 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21626 char c
= arr
[upos
];
21630 for (i
= 0; i
< ulen
; i
++)
21632 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21638 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21640 if ( arr_len
== 0) return (arr_len
);
21641 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21645 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21647 int new_pos
= arr_pos
* 2;
21649 arr
[new_pos
] = arr
[arr_pos
];
21651 arr
[new_pos
+ 1] = arr
[arr_pos
];
21654 return (arr_len
* 2);
21657 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21659 if (upos
>= arr_len
) return (arr_len
);
21660 if (upos2
>= arr_len
) return (arr_len
);
21662 MANGLE_SWITCH (arr
, upos
, upos2
);
21667 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21669 MANGLE_SWITCH (arr
, upos
, upos2
);
21674 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21676 if (upos
>= arr_len
) return (arr_len
);
21683 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21685 if (upos
>= arr_len
) return (arr_len
);
21692 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21694 if (upos
>= arr_len
) return (arr_len
);
21701 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21703 if (upos
>= arr_len
) return (arr_len
);
21710 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21712 int upper_next
= 1;
21716 for (pos
= 0; pos
< arr_len
; pos
++)
21718 if (arr
[pos
] == ' ')
21729 MANGLE_UPPER_AT (arr
, pos
);
21733 MANGLE_LOWER_AT (arr
, pos
);
21740 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21742 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21748 for (j
= 0; j
< rp_gen_num
; j
++)
21755 switch ((char) get_random_num (0, 9))
21758 r
= get_random_num (0, sizeof (grp_op_nop
));
21759 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21763 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21764 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21765 p1
= get_random_num (0, sizeof (grp_pos
));
21766 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21770 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21771 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21772 p1
= get_random_num (1, 6);
21773 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21777 r
= get_random_num (0, sizeof (grp_op_chr
));
21778 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21779 p1
= get_random_num (0x20, 0x7e);
21780 rule_buf
[rule_pos
++] = (char) p1
;
21784 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21785 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21786 p1
= get_random_num (0x20, 0x7e);
21787 rule_buf
[rule_pos
++] = (char) p1
;
21788 p2
= get_random_num (0x20, 0x7e);
21790 p2
= get_random_num (0x20, 0x7e);
21791 rule_buf
[rule_pos
++] = (char) p2
;
21795 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21796 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21797 p1
= get_random_num (0, sizeof (grp_pos
));
21798 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21799 p2
= get_random_num (0x20, 0x7e);
21800 rule_buf
[rule_pos
++] = (char) p2
;
21804 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21805 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21806 p1
= get_random_num (0, sizeof (grp_pos
));
21807 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21808 p2
= get_random_num (0, sizeof (grp_pos
));
21810 p2
= get_random_num (0, sizeof (grp_pos
));
21811 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21815 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21816 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21817 p1
= get_random_num (0, sizeof (grp_pos
));
21818 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21819 p2
= get_random_num (1, sizeof (grp_pos
));
21821 p2
= get_random_num (1, sizeof (grp_pos
));
21822 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21826 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21827 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21828 p1
= get_random_num (0, sizeof (grp_pos
));
21829 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21830 p2
= get_random_num (1, sizeof (grp_pos
));
21831 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21832 p3
= get_random_num (0, sizeof (grp_pos
));
21833 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21841 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21843 char mem
[BLOCK_SIZE
] = { 0 };
21845 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21847 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21849 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21851 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21853 int out_len
= in_len
;
21854 int mem_len
= in_len
;
21856 memcpy (out
, in
, out_len
);
21860 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21865 switch (rule
[rule_pos
])
21870 case RULE_OP_MANGLE_NOOP
:
21873 case RULE_OP_MANGLE_LREST
:
21874 out_len
= mangle_lrest (out
, out_len
);
21877 case RULE_OP_MANGLE_UREST
:
21878 out_len
= mangle_urest (out
, out_len
);
21881 case RULE_OP_MANGLE_LREST_UFIRST
:
21882 out_len
= mangle_lrest (out
, out_len
);
21883 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21886 case RULE_OP_MANGLE_UREST_LFIRST
:
21887 out_len
= mangle_urest (out
, out_len
);
21888 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21891 case RULE_OP_MANGLE_TREST
:
21892 out_len
= mangle_trest (out
, out_len
);
21895 case RULE_OP_MANGLE_TOGGLE_AT
:
21896 NEXT_RULEPOS (rule_pos
);
21897 NEXT_RPTOI (rule
, rule_pos
, upos
);
21898 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21901 case RULE_OP_MANGLE_REVERSE
:
21902 out_len
= mangle_reverse (out
, out_len
);
21905 case RULE_OP_MANGLE_DUPEWORD
:
21906 out_len
= mangle_double (out
, out_len
);
21909 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21910 NEXT_RULEPOS (rule_pos
);
21911 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21912 out_len
= mangle_double_times (out
, out_len
, ulen
);
21915 case RULE_OP_MANGLE_REFLECT
:
21916 out_len
= mangle_reflect (out
, out_len
);
21919 case RULE_OP_MANGLE_ROTATE_LEFT
:
21920 mangle_rotate_left (out
, out_len
);
21923 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21924 mangle_rotate_right (out
, out_len
);
21927 case RULE_OP_MANGLE_APPEND
:
21928 NEXT_RULEPOS (rule_pos
);
21929 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21932 case RULE_OP_MANGLE_PREPEND
:
21933 NEXT_RULEPOS (rule_pos
);
21934 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21937 case RULE_OP_MANGLE_DELETE_FIRST
:
21938 out_len
= mangle_delete_at (out
, out_len
, 0);
21941 case RULE_OP_MANGLE_DELETE_LAST
:
21942 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21945 case RULE_OP_MANGLE_DELETE_AT
:
21946 NEXT_RULEPOS (rule_pos
);
21947 NEXT_RPTOI (rule
, rule_pos
, upos
);
21948 out_len
= mangle_delete_at (out
, out_len
, upos
);
21951 case RULE_OP_MANGLE_EXTRACT
:
21952 NEXT_RULEPOS (rule_pos
);
21953 NEXT_RPTOI (rule
, rule_pos
, upos
);
21954 NEXT_RULEPOS (rule_pos
);
21955 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21956 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21959 case RULE_OP_MANGLE_OMIT
:
21960 NEXT_RULEPOS (rule_pos
);
21961 NEXT_RPTOI (rule
, rule_pos
, upos
);
21962 NEXT_RULEPOS (rule_pos
);
21963 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21964 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21967 case RULE_OP_MANGLE_INSERT
:
21968 NEXT_RULEPOS (rule_pos
);
21969 NEXT_RPTOI (rule
, rule_pos
, upos
);
21970 NEXT_RULEPOS (rule_pos
);
21971 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21974 case RULE_OP_MANGLE_OVERSTRIKE
:
21975 NEXT_RULEPOS (rule_pos
);
21976 NEXT_RPTOI (rule
, rule_pos
, upos
);
21977 NEXT_RULEPOS (rule_pos
);
21978 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21981 case RULE_OP_MANGLE_TRUNCATE_AT
:
21982 NEXT_RULEPOS (rule_pos
);
21983 NEXT_RPTOI (rule
, rule_pos
, upos
);
21984 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21987 case RULE_OP_MANGLE_REPLACE
:
21988 NEXT_RULEPOS (rule_pos
);
21989 NEXT_RULEPOS (rule_pos
);
21990 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21993 case RULE_OP_MANGLE_PURGECHAR
:
21994 NEXT_RULEPOS (rule_pos
);
21995 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21998 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22002 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22003 NEXT_RULEPOS (rule_pos
);
22004 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22005 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22008 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22009 NEXT_RULEPOS (rule_pos
);
22010 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22011 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22014 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22015 out_len
= mangle_dupechar (out
, out_len
);
22018 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22019 NEXT_RULEPOS (rule_pos
);
22020 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22021 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22024 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22025 NEXT_RULEPOS (rule_pos
);
22026 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22027 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22030 case RULE_OP_MANGLE_SWITCH_FIRST
:
22031 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22034 case RULE_OP_MANGLE_SWITCH_LAST
:
22035 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22038 case RULE_OP_MANGLE_SWITCH_AT
:
22039 NEXT_RULEPOS (rule_pos
);
22040 NEXT_RPTOI (rule
, rule_pos
, upos
);
22041 NEXT_RULEPOS (rule_pos
);
22042 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22043 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22046 case RULE_OP_MANGLE_CHR_SHIFTL
:
22047 NEXT_RULEPOS (rule_pos
);
22048 NEXT_RPTOI (rule
, rule_pos
, upos
);
22049 mangle_chr_shiftl (out
, out_len
, upos
);
22052 case RULE_OP_MANGLE_CHR_SHIFTR
:
22053 NEXT_RULEPOS (rule_pos
);
22054 NEXT_RPTOI (rule
, rule_pos
, upos
);
22055 mangle_chr_shiftr (out
, out_len
, upos
);
22058 case RULE_OP_MANGLE_CHR_INCR
:
22059 NEXT_RULEPOS (rule_pos
);
22060 NEXT_RPTOI (rule
, rule_pos
, upos
);
22061 mangle_chr_incr (out
, out_len
, upos
);
22064 case RULE_OP_MANGLE_CHR_DECR
:
22065 NEXT_RULEPOS (rule_pos
);
22066 NEXT_RPTOI (rule
, rule_pos
, upos
);
22067 mangle_chr_decr (out
, out_len
, upos
);
22070 case RULE_OP_MANGLE_REPLACE_NP1
:
22071 NEXT_RULEPOS (rule_pos
);
22072 NEXT_RPTOI (rule
, rule_pos
, upos
);
22073 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22076 case RULE_OP_MANGLE_REPLACE_NM1
:
22077 NEXT_RULEPOS (rule_pos
);
22078 NEXT_RPTOI (rule
, rule_pos
, upos
);
22079 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22082 case RULE_OP_MANGLE_TITLE
:
22083 out_len
= mangle_title (out
, out_len
);
22086 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22087 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22088 NEXT_RULEPOS (rule_pos
);
22089 NEXT_RPTOI (rule
, rule_pos
, upos
);
22090 NEXT_RULEPOS (rule_pos
);
22091 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22092 NEXT_RULEPOS (rule_pos
);
22093 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22094 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22097 case RULE_OP_MANGLE_APPEND_MEMORY
:
22098 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22099 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22100 memcpy (out
+ out_len
, mem
, mem_len
);
22101 out_len
+= mem_len
;
22104 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22105 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22106 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22107 memcpy (mem
+ mem_len
, out
, out_len
);
22108 out_len
+= mem_len
;
22109 memcpy (out
, mem
, out_len
);
22112 case RULE_OP_MEMORIZE_WORD
:
22113 memcpy (mem
, out
, out_len
);
22117 case RULE_OP_REJECT_LESS
:
22118 NEXT_RULEPOS (rule_pos
);
22119 NEXT_RPTOI (rule
, rule_pos
, upos
);
22120 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22123 case RULE_OP_REJECT_GREATER
:
22124 NEXT_RULEPOS (rule_pos
);
22125 NEXT_RPTOI (rule
, rule_pos
, upos
);
22126 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22129 case RULE_OP_REJECT_CONTAIN
:
22130 NEXT_RULEPOS (rule_pos
);
22131 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22134 case RULE_OP_REJECT_NOT_CONTAIN
:
22135 NEXT_RULEPOS (rule_pos
);
22136 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22139 case RULE_OP_REJECT_EQUAL_FIRST
:
22140 NEXT_RULEPOS (rule_pos
);
22141 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22144 case RULE_OP_REJECT_EQUAL_LAST
:
22145 NEXT_RULEPOS (rule_pos
);
22146 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22149 case RULE_OP_REJECT_EQUAL_AT
:
22150 NEXT_RULEPOS (rule_pos
);
22151 NEXT_RPTOI (rule
, rule_pos
, upos
);
22152 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22153 NEXT_RULEPOS (rule_pos
);
22154 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22157 case RULE_OP_REJECT_CONTAINS
:
22158 NEXT_RULEPOS (rule_pos
);
22159 NEXT_RPTOI (rule
, rule_pos
, upos
);
22160 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22161 NEXT_RULEPOS (rule_pos
);
22162 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22163 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22166 case RULE_OP_REJECT_MEMORY
:
22167 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22171 return (RULE_RC_SYNTAX_ERROR
);
22176 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);