2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2674 #if defined(_WIN) && defined(HAVE_NVAPI)
2675 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2679 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2683 log_info ("WARN: No NvAPI adapters found");
2690 #endif // _WIN && HAVE_NVAPI
2692 #if defined(LINUX) && defined(HAVE_NVML)
2693 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2697 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2699 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2701 // can be used to determine if the device by index matches the cuda device by index
2702 // char name[100]; memset (name, 0, sizeof (name));
2703 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2710 log_info ("WARN: No NVML adapters found");
2717 #endif // LINUX && HAVE_NVML
2720 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2722 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2724 if (iNumberAdapters
== 0)
2726 log_info ("WARN: No ADL adapters found.");
2735 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2737 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2738 ADLODParameters lpOdParameters;
2740 lpOdParameters.iSize = sizeof (ADLODParameters);
2741 size_t plevels_size = 0;
2743 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2745 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2746 __func__, iAdapterIndex,
2747 lpOdParameters.iNumberOfPerformanceLevels,
2748 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2749 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2751 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2753 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2755 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2757 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2759 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2760 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2761 __func__, iAdapterIndex, j,
2762 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2764 myfree (lpOdPerformanceLevels);
2770 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2772 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2774 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2776 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2778 return lpAdapterInfo
;
2783 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2786 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2790 for (uint i = 0; i < num_adl_adapters; i++)
2792 int opencl_bus_num = hm_device[i].busid;
2793 int opencl_dev_num = hm_device[i].devid;
2795 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2803 if (idx >= DEVICES_MAX) return -1;
2808 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2810 for (uint i = 0; i < opencl_num_devices; i++)
2812 cl_device_topology_amd device_topology;
2814 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2816 hm_device[i].busid = device_topology.pcie.bus;
2817 hm_device[i].devid = device_topology.pcie.device;
2822 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2824 // basically bubble sort
2826 for (int i
= 0; i
< num_adl_adapters
; i
++)
2828 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2830 // get info of adapter [x]
2832 u32 adapter_index_x
= valid_adl_device_list
[j
];
2833 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2835 u32 bus_num_x
= info_x
.iBusNumber
;
2836 u32 dev_num_x
= info_x
.iDeviceNumber
;
2838 // get info of adapter [y]
2840 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2841 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2843 u32 bus_num_y
= info_y
.iBusNumber
;
2844 u32 dev_num_y
= info_y
.iDeviceNumber
;
2848 if (bus_num_y
< bus_num_x
)
2852 else if (bus_num_y
== bus_num_x
)
2854 if (dev_num_y
< dev_num_x
)
2862 u32 temp
= valid_adl_device_list
[j
+ 1];
2864 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2865 valid_adl_device_list
[j
+ 0] = temp
;
2871 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2873 *num_adl_adapters
= 0;
2875 u32
*adl_adapters
= NULL
;
2877 int *bus_numbers
= NULL
;
2878 int *device_numbers
= NULL
;
2880 for (int i
= 0; i
< iNumberAdapters
; i
++)
2882 AdapterInfo info
= lpAdapterInfo
[i
];
2884 if (strlen (info
.strUDID
) < 1) continue;
2887 if (info
.iVendorID
!= 1002) continue;
2889 if (info
.iVendorID
!= 0x1002) continue;
2892 if (info
.iBusNumber
< 0) continue;
2893 if (info
.iDeviceNumber
< 0) continue;
2897 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2899 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2906 if (found
) continue;
2908 // add it to the list
2910 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 adl_adapters
[*num_adl_adapters
] = i
;
2914 // rest is just bookkeeping
2916 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2917 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2920 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2922 (*num_adl_adapters
)++;
2925 myfree (bus_numbers
);
2926 myfree (device_numbers
);
2928 // sort the list by increasing bus id, device id number
2930 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2932 return adl_adapters
;
2935 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2937 // loop through all valid devices
2939 for (int i
= 0; i
< num_adl_adapters
; i
++)
2941 u32 adapter_index
= valid_adl_device_list
[i
];
2945 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2947 // unfortunately this doesn't work since bus id and dev id are not unique
2948 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2949 // if (opencl_device_index == -1) continue;
2951 int opencl_device_index
= i
;
2953 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2955 // get fanspeed info
2957 if (hm_device
[opencl_device_index
].od_version
== 5)
2959 ADLFanSpeedInfo FanSpeedInfo
;
2961 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2963 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2965 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2967 // check read and write capability in fanspeedinfo
2969 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2970 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2972 hm_device
[opencl_device_index
].fan_supported
= 1;
2976 hm_device
[opencl_device_index
].fan_supported
= 0;
2979 else // od_version == 6
2981 ADLOD6FanSpeedInfo faninfo
;
2983 memset (&faninfo
, 0, sizeof (faninfo
));
2985 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2987 // check read capability in fanspeedinfo
2989 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2991 hm_device
[opencl_device_index
].fan_supported
= 1;
2995 hm_device
[opencl_device_index
].fan_supported
= 0;
3003 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3005 for (int i
= 0; i
< num_adl_adapters
; i
++)
3007 u32 adapter_index
= valid_adl_device_list
[i
];
3011 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3013 // get overdrive version
3015 int od_supported
= 0;
3019 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3021 // store the overdrive version in hm_device
3023 // unfortunately this doesn't work since bus id and dev id are not unique
3024 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3025 // if (opencl_device_index == -1) continue;
3027 int opencl_device_index
= i
;
3029 hm_device
[opencl_device_index
].od_version
= od_version
;
3035 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3037 for (int i
= 0; i
< num_adl_adapters
; i
++)
3039 u32 adapter_index
= valid_adl_device_list
[i
];
3043 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3045 // store the iAdapterIndex in hm_device
3047 // unfortunately this doesn't work since bus id and dev id are not unique
3048 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3049 // if (opencl_device_index == -1) continue;
3051 int opencl_device_index
= i
;
3053 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3056 return num_adl_adapters
;
3060 int hm_get_temperature_with_device_id (const uint device_id
)
3062 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3091 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3092 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3094 #if defined(LINUX) && defined(HAVE_NVML)
3095 int temperature
= 0;
3097 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3102 #if defined(WIN) && defined(HAVE_NVAPI)
3103 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3105 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3106 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3107 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3108 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3110 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3112 return pThermalSettings
.sensor
[0].currentTemp
;
3113 #endif // WIN && HAVE_NVAPI
3115 #endif // HAVE_NVML || HAVE_NVAPI
3120 int hm_get_fanspeed_with_device_id (const uint device_id
)
3122 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3123 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3125 if (data
.hm_device
[device_id
].fan_supported
== 1)
3128 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLFanSpeedValue lpFanSpeedValue
;
3136 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3138 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3139 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3140 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3142 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3144 return lpFanSpeedValue
.iFanSpeed
;
3146 else // od_version == 6
3148 ADLOD6FanSpeedInfo faninfo
;
3150 memset (&faninfo
, 0, sizeof (faninfo
));
3152 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3154 return faninfo
.iFanSpeedPercent
;
3160 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3161 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3163 #if defined(LINUX) && defined(HAVE_NVML)
3166 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3171 #if defined(WIN) && defined(HAVE_NVAPI)
3173 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3175 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3177 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3179 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3182 #endif // HAVE_NVML || HAVE_NVAPI
3188 int hm_get_utilization_with_device_id (const uint device_id
)
3190 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3193 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3197 ADLPMActivity PMActivity
;
3199 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3201 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3203 return PMActivity
.iActivityPercent
;
3208 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3209 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3211 #if defined(LINUX) && defined(HAVE_NVML)
3212 nvmlUtilization_t utilization
;
3214 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3216 return utilization
.gpu
;
3219 #if defined(WIN) && defined(HAVE_NVAPI)
3220 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3222 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3224 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3226 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3229 #endif // HAVE_NVML || HAVE_NVAPI
3235 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3237 if (data
.hm_device
[device_id
].fan_supported
== 1)
3241 if (data
.hm_device
[device_id
].od_version
== 5)
3243 ADLFanSpeedValue lpFanSpeedValue
;
3245 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3247 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3248 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3249 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3250 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3252 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3256 else // od_version == 6
3258 ADLOD6FanSpeedValue fan_speed_value
;
3260 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3262 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3263 fan_speed_value
.iFanSpeed
= fanspeed
;
3265 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3276 // helper function for status display
3278 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3280 #define VALUE_NOT_AVAILABLE "N/A"
3284 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3288 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3291 #endif // HAVE_HWMON
3297 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3299 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3301 if (css_cnt
> SP_PW_MAX
)
3303 log_error ("ERROR: mask length is too long");
3308 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3310 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3312 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3313 uint cs_len
= css
[css_pos
].cs_len
;
3315 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3317 uint c
= cs_buf
[cs_pos
] & 0xff;
3324 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3326 cs_t
*cs
= &css
[css_cnt
];
3328 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3330 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3334 for (i
= 0; i
< cs
->cs_len
; i
++)
3336 const uint u
= cs
->cs_buf
[i
];
3341 for (i
= 0; i
< in_len
; i
++)
3343 uint u
= in_buf
[i
] & 0xff;
3345 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3347 if (css_uniq
[u
] == 1) continue;
3351 cs
->cs_buf
[cs
->cs_len
] = u
;
3359 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3363 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3365 uint p0
= in_buf
[in_pos
] & 0xff;
3367 if (interpret
== 1 && p0
== '?')
3371 if (in_pos
== in_len
) break;
3373 uint p1
= in_buf
[in_pos
] & 0xff;
3377 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3379 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3381 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3383 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3385 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3387 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3389 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3390 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3392 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3393 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3395 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3396 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3398 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3399 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3401 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3403 default: log_error ("Syntax error: %s", in_buf
);
3409 if (data
.hex_charset
)
3413 if (in_pos
== in_len
)
3415 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3420 uint p1
= in_buf
[in_pos
] & 0xff;
3422 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3424 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3431 chr
= hex_convert (p1
) << 0;
3432 chr
|= hex_convert (p0
) << 4;
3434 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3440 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3446 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3450 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3452 sum
*= css
[css_pos
].cs_len
;
3458 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3460 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3465 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3467 char p0
= mask_buf
[mask_pos
];
3473 if (mask_pos
== mask_len
) break;
3475 char p1
= mask_buf
[mask_pos
];
3481 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3483 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3485 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3487 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3489 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3491 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3493 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3494 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3496 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3497 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3499 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3500 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3502 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3503 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3505 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3507 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3513 if (data
.hex_charset
)
3517 // if there is no 2nd hex character, show an error:
3519 if (mask_pos
== mask_len
)
3521 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3526 char p1
= mask_buf
[mask_pos
];
3528 // if they are not valid hex character, show an error:
3530 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3532 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3539 chr
|= hex_convert (p1
) << 0;
3540 chr
|= hex_convert (p0
) << 4;
3542 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3548 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3555 log_error ("ERROR: invalid mask length (0)");
3565 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3567 for (int i
= 0; i
< css_cnt
; i
++)
3569 uint len
= css
[i
].cs_len
;
3570 u64 next
= val
/ len
;
3571 uint pos
= val
% len
;
3572 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3577 void mp_cut_at (char *mask
, uint max
)
3581 uint mask_len
= strlen (mask
);
3583 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3585 if (mask
[i
] == '?') i
++;
3591 void mp_setup_sys (cs_t
*mp_sys
)
3595 uint donec
[CHARSIZ
] = { 0 };
3597 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3598 mp_sys
[0].cs_buf
[pos
++] = chr
;
3599 mp_sys
[0].cs_len
= pos
; }
3601 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3602 mp_sys
[1].cs_buf
[pos
++] = chr
;
3603 mp_sys
[1].cs_len
= pos
; }
3605 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3606 mp_sys
[2].cs_buf
[pos
++] = chr
;
3607 mp_sys
[2].cs_len
= pos
; }
3609 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3610 mp_sys
[3].cs_buf
[pos
++] = chr
;
3611 mp_sys
[3].cs_len
= pos
; }
3613 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3614 mp_sys
[4].cs_len
= pos
; }
3616 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3617 mp_sys
[5].cs_len
= pos
; }
3620 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3622 FILE *fp
= fopen (buf
, "rb");
3624 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3626 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3630 char mp_file
[1024] = { 0 };
3632 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3636 len
= in_superchop (mp_file
);
3640 log_info ("WARNING: charset file corrupted");
3642 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3646 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3651 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3653 mp_usr
[index
].cs_len
= 0;
3655 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3658 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3660 char *new_mask_buf
= (char *) mymalloc (256);
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 if (css_pos
== len
) break;
3670 char p0
= mask_buf
[mask_pos
];
3672 new_mask_buf
[mask_pos
] = p0
;
3678 if (mask_pos
== mask_len
) break;
3680 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3684 if (data
.hex_charset
)
3688 if (mask_pos
== mask_len
)
3690 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3695 char p1
= mask_buf
[mask_pos
];
3697 // if they are not valid hex character, show an error:
3699 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3701 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3706 new_mask_buf
[mask_pos
] = p1
;
3711 if (css_pos
== len
) return (new_mask_buf
);
3713 myfree (new_mask_buf
);
3722 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3728 for (i
= start
; i
< stop
; i
++)
3730 sum
*= root_css_buf
[i
].cs_len
;
3736 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3740 cs_t
*cs
= &root_css_buf
[start
];
3744 for (i
= start
; i
< stop
; i
++)
3746 const u64 m
= v
% cs
->cs_len
;
3747 const u64 d
= v
/ cs
->cs_len
;
3751 const uint k
= cs
->cs_buf
[m
];
3753 pw_buf
[i
- start
] = (char) k
;
3755 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3759 int sp_comp_val (const void *p1
, const void *p2
)
3761 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3762 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3764 return b2
->val
- b1
->val
;
3767 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3774 * Initialize hcstats
3777 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3779 u64
*root_stats_ptr
= root_stats_buf
;
3781 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3783 for (i
= 0; i
< SP_PW_MAX
; i
++)
3785 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3787 root_stats_ptr
+= CHARSIZ
;
3790 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3792 u64
*markov_stats_ptr
= markov_stats_buf
;
3794 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3796 for (i
= 0; i
< SP_PW_MAX
; i
++)
3798 for (j
= 0; j
< CHARSIZ
; j
++)
3800 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3802 markov_stats_ptr
+= CHARSIZ
;
3812 char hcstat_tmp
[256] = { 0 };
3814 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3816 hcstat
= hcstat_tmp
;
3819 FILE *fd
= fopen (hcstat
, "rb");
3823 log_error ("%s: %s", hcstat
, strerror (errno
));
3828 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3830 log_error ("%s: Could not load data", hcstat
);
3837 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3839 log_error ("%s: Could not load data", hcstat
);
3849 * Markov modifier of hcstat_table on user request
3854 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3855 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3860 /* Add all stats to first position */
3862 for (i
= 1; i
< SP_PW_MAX
; i
++)
3864 u64
*out
= root_stats_buf_by_pos
[0];
3865 u64
*in
= root_stats_buf_by_pos
[i
];
3867 for (j
= 0; j
< CHARSIZ
; j
++)
3873 for (i
= 1; i
< SP_PW_MAX
; i
++)
3875 u64
*out
= markov_stats_buf_by_key
[0][0];
3876 u64
*in
= markov_stats_buf_by_key
[i
][0];
3878 for (j
= 0; j
< CHARSIZ
; j
++)
3880 for (k
= 0; k
< CHARSIZ
; k
++)
3887 /* copy them to all pw_positions */
3889 for (i
= 1; i
< SP_PW_MAX
; i
++)
3891 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3894 for (i
= 1; i
< SP_PW_MAX
; i
++)
3896 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3904 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3906 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3908 for (i
= 0; i
< SP_PW_MAX
; i
++)
3910 root_table_buf_by_pos
[i
] = root_table_ptr
;
3912 root_table_ptr
+= CHARSIZ
;
3915 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3917 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3919 for (i
= 0; i
< SP_PW_MAX
; i
++)
3921 for (j
= 0; j
< CHARSIZ
; j
++)
3923 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3925 markov_table_ptr
+= CHARSIZ
;
3930 * Convert hcstat to tables
3933 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3935 uint key
= i
% CHARSIZ
;
3937 root_table_buf
[i
].key
= key
;
3938 root_table_buf
[i
].val
= root_stats_buf
[i
];
3941 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3943 uint key
= i
% CHARSIZ
;
3945 markov_table_buf
[i
].key
= key
;
3946 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3949 myfree (root_stats_buf
);
3950 myfree (markov_stats_buf
);
3956 for (i
= 0; i
< SP_PW_MAX
; i
++)
3958 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3961 for (i
= 0; i
< SP_PW_MAX
; i
++)
3963 for (j
= 0; j
< CHARSIZ
; j
++)
3965 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3970 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3973 * Convert tables to css
3976 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3978 uint pw_pos
= i
/ CHARSIZ
;
3980 cs_t
*cs
= &root_css_buf
[pw_pos
];
3982 if (cs
->cs_len
== threshold
) continue;
3984 uint key
= root_table_buf
[i
].key
;
3986 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3988 cs
->cs_buf
[cs
->cs_len
] = key
;
3994 * Convert table to css
3997 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3999 uint c
= i
/ CHARSIZ
;
4001 cs_t
*cs
= &markov_css_buf
[c
];
4003 if (cs
->cs_len
== threshold
) continue;
4005 uint pw_pos
= c
/ CHARSIZ
;
4007 uint key
= markov_table_buf
[i
].key
;
4009 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4011 cs
->cs_buf
[cs
->cs_len
] = key
;
4017 for (uint i = 0; i < 8; i++)
4019 for (uint j = 0x20; j < 0x80; j++)
4021 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4023 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4025 for (uint k = 0; k < 10; k++)
4027 printf (" %u\n", ptr->cs_buf[k]);
4034 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4036 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4038 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4048 for (uint j
= 1; j
< CHARSIZ
; j
++)
4058 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4060 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4062 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4064 out
+= CHARSIZ
* CHARSIZ
;
4065 in
+= CHARSIZ
* CHARSIZ
;
4067 for (uint j
= 0; j
< CHARSIZ
; j
++)
4074 for (uint k
= 1; k
< CHARSIZ
; k
++)
4086 * mixed shared functions
4089 void dump_hex (const u8
*s
, const int sz
)
4091 for (int i
= 0; i
< sz
; i
++)
4093 log_info_nn ("%02x ", s
[i
]);
4099 void usage_mini_print (const char *progname
)
4101 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4104 void usage_big_print (const char *progname
)
4106 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4109 char *get_exec_path ()
4111 int exec_path_len
= 1024;
4113 char *exec_path
= (char *) mymalloc (exec_path_len
);
4117 char tmp
[32] = { 0 };
4119 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4121 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4125 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4129 uint size
= exec_path_len
;
4131 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4133 log_error("! executable path buffer too small\n");
4138 const int len
= strlen (exec_path
);
4141 #error Your Operating System is not supported or detected
4149 char *get_install_dir (const char *progname
)
4151 char *install_dir
= mystrdup (progname
);
4152 char *last_slash
= NULL
;
4154 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4158 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4164 install_dir
[0] = '.';
4168 return (install_dir
);
4171 char *get_profile_dir (const char *homedir
)
4173 #define DOT_HASHCAT ".hashcat"
4175 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4177 char *profile_dir
= (char *) mymalloc (len
+ 1);
4179 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4184 char *get_session_dir (const char *profile_dir
)
4186 #define SESSIONS_FOLDER "sessions"
4188 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4190 char *session_dir
= (char *) mymalloc (len
+ 1);
4192 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4197 uint
count_lines (FILE *fd
)
4201 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4207 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4209 if (nread
< 1) continue;
4213 for (i
= 0; i
< nread
; i
++)
4215 if (prev
== '\n') cnt
++;
4226 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4230 FILE *fd
= fopen (filename
, "rb");
4234 log_error ("%s: %s", filename
, strerror (errno
));
4239 #define MAX_KEY_SIZE (1024 * 1024)
4241 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4243 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4249 for (int fpos
= 0; fpos
< nread
; fpos
++)
4251 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4253 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4256 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4258 if (kpos
>= 64) kpos
= 0;
4265 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4269 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4270 if (CPU_ISSET(core
, cpu_set
)) break;
4272 thread_affinity_policy_data_t policy
= { core
};
4274 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4276 if (data
.quiet
== 0)
4278 if (rc
!= KERN_SUCCESS
)
4280 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4288 void set_cpu_affinity (char *cpu_affinity
)
4291 DWORD_PTR aff_mask
= 0;
4299 char *devices
= strdup (cpu_affinity
);
4301 char *next
= strtok (devices
, ",");
4305 uint cpu_id
= atoi (next
);
4320 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4326 aff_mask
|= 1 << (cpu_id
- 1);
4328 CPU_SET ((cpu_id
- 1), &cpuset
);
4331 } while ((next
= strtok (NULL
, ",")) != NULL
);
4337 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4338 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4340 pthread_t thread
= pthread_self ();
4341 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4345 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4347 char *element
, *end
;
4349 end
= (char *) base
+ nmemb
* size
;
4351 for (element
= (char *) base
; element
< end
; element
+= size
)
4352 if (!compar (element
, key
))
4358 int sort_by_u32 (const void *v1
, const void *v2
)
4360 const u32
*s1
= (const u32
*) v1
;
4361 const u32
*s2
= (const u32
*) v2
;
4366 int sort_by_salt (const void *v1
, const void *v2
)
4368 const salt_t
*s1
= (const salt_t
*) v1
;
4369 const salt_t
*s2
= (const salt_t
*) v2
;
4371 const int res1
= s1
->salt_len
- s2
->salt_len
;
4373 if (res1
!= 0) return (res1
);
4375 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4377 if (res2
!= 0) return (res2
);
4385 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4386 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4393 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4394 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4400 int sort_by_salt_buf (const void *v1
, const void *v2
)
4402 const pot_t
*p1
= (const pot_t
*) v1
;
4403 const pot_t
*p2
= (const pot_t
*) v2
;
4405 const hash_t
*h1
= &p1
->hash
;
4406 const hash_t
*h2
= &p2
->hash
;
4408 const salt_t
*s1
= h1
->salt
;
4409 const salt_t
*s2
= h2
->salt
;
4415 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4416 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4422 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4424 const hash_t
*h1
= (const hash_t
*) v1
;
4425 const hash_t
*h2
= (const hash_t
*) v2
;
4427 const salt_t
*s1
= h1
->salt
;
4428 const salt_t
*s2
= h2
->salt
;
4430 // testphase: this should work
4435 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4436 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4439 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4440 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4441 if (s1->salt_len > s2->salt_len) return ( 1);
4442 if (s1->salt_len < s2->salt_len) return (-1);
4444 uint n = s1->salt_len;
4448 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4449 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4456 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4458 const hash_t
*h1
= (const hash_t
*) v1
;
4459 const hash_t
*h2
= (const hash_t
*) v2
;
4461 const salt_t
*s1
= h1
->salt
;
4462 const salt_t
*s2
= h2
->salt
;
4464 // 16 - 2 (since last 2 uints contain the digest)
4469 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4470 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4476 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4478 const hash_t
*h1
= (const hash_t
*) v1
;
4479 const hash_t
*h2
= (const hash_t
*) v2
;
4481 const void *d1
= h1
->digest
;
4482 const void *d2
= h2
->digest
;
4484 return data
.sort_by_digest (d1
, d2
);
4487 int sort_by_hash (const void *v1
, const void *v2
)
4489 const hash_t
*h1
= (const hash_t
*) v1
;
4490 const hash_t
*h2
= (const hash_t
*) v2
;
4494 const salt_t
*s1
= h1
->salt
;
4495 const salt_t
*s2
= h2
->salt
;
4497 int res
= sort_by_salt (s1
, s2
);
4499 if (res
!= 0) return (res
);
4502 const void *d1
= h1
->digest
;
4503 const void *d2
= h2
->digest
;
4505 return data
.sort_by_digest (d1
, d2
);
4508 int sort_by_pot (const void *v1
, const void *v2
)
4510 const pot_t
*p1
= (const pot_t
*) v1
;
4511 const pot_t
*p2
= (const pot_t
*) v2
;
4513 const hash_t
*h1
= &p1
->hash
;
4514 const hash_t
*h2
= &p2
->hash
;
4516 return sort_by_hash (h1
, h2
);
4519 int sort_by_mtime (const void *p1
, const void *p2
)
4521 const char **f1
= (const char **) p1
;
4522 const char **f2
= (const char **) p2
;
4524 struct stat s1
; stat (*f1
, &s1
);
4525 struct stat s2
; stat (*f2
, &s2
);
4527 return s2
.st_mtime
- s1
.st_mtime
;
4530 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4532 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4533 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4535 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4538 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4540 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4541 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4543 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4546 int sort_by_stringptr (const void *p1
, const void *p2
)
4548 const char **s1
= (const char **) p1
;
4549 const char **s2
= (const char **) p2
;
4551 return strcmp (*s1
, *s2
);
4554 int sort_by_dictstat (const void *s1
, const void *s2
)
4556 dictstat_t
*d1
= (dictstat_t
*) s1
;
4557 dictstat_t
*d2
= (dictstat_t
*) s2
;
4560 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4562 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4565 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4568 int sort_by_bitmap (const void *p1
, const void *p2
)
4570 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4571 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4573 return b1
->collisions
- b2
->collisions
;
4576 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4578 const u32
*d1
= (const u32
*) v1
;
4579 const u32
*d2
= (const u32
*) v2
;
4585 if (d1
[n
] > d2
[n
]) return ( 1);
4586 if (d1
[n
] < d2
[n
]) return (-1);
4592 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4594 const u32
*d1
= (const u32
*) v1
;
4595 const u32
*d2
= (const u32
*) v2
;
4601 if (d1
[n
] > d2
[n
]) return ( 1);
4602 if (d1
[n
] < d2
[n
]) return (-1);
4608 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4610 const u32
*d1
= (const u32
*) v1
;
4611 const u32
*d2
= (const u32
*) v2
;
4617 if (d1
[n
] > d2
[n
]) return ( 1);
4618 if (d1
[n
] < d2
[n
]) return (-1);
4624 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4626 const u32
*d1
= (const u32
*) v1
;
4627 const u32
*d2
= (const u32
*) v2
;
4633 if (d1
[n
] > d2
[n
]) return ( 1);
4634 if (d1
[n
] < d2
[n
]) return (-1);
4640 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4642 const u32
*d1
= (const u32
*) v1
;
4643 const u32
*d2
= (const u32
*) v2
;
4649 if (d1
[n
] > d2
[n
]) return ( 1);
4650 if (d1
[n
] < d2
[n
]) return (-1);
4656 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4658 const u32
*d1
= (const u32
*) v1
;
4659 const u32
*d2
= (const u32
*) v2
;
4665 if (d1
[n
] > d2
[n
]) return ( 1);
4666 if (d1
[n
] < d2
[n
]) return (-1);
4672 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4674 const u32
*d1
= (const u32
*) v1
;
4675 const u32
*d2
= (const u32
*) v2
;
4681 if (d1
[n
] > d2
[n
]) return ( 1);
4682 if (d1
[n
] < d2
[n
]) return (-1);
4688 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4690 const u32
*d1
= (const u32
*) v1
;
4691 const u32
*d2
= (const u32
*) v2
;
4697 if (d1
[n
] > d2
[n
]) return ( 1);
4698 if (d1
[n
] < d2
[n
]) return (-1);
4704 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4706 const u64
*d1
= (const u64
*) v1
;
4707 const u64
*d2
= (const u64
*) v2
;
4713 if (d1
[n
] > d2
[n
]) return ( 1);
4714 if (d1
[n
] < d2
[n
]) return (-1);
4720 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4722 const u64
*d1
= (const u64
*) v1
;
4723 const u64
*d2
= (const u64
*) v2
;
4729 if (d1
[n
] > d2
[n
]) return ( 1);
4730 if (d1
[n
] < d2
[n
]) return (-1);
4736 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4738 const u64
*d1
= (const u64
*) v1
;
4739 const u64
*d2
= (const u64
*) v2
;
4745 if (d1
[n
] > d2
[n
]) return ( 1);
4746 if (d1
[n
] < d2
[n
]) return (-1);
4752 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4754 const u32
*d1
= (const u32
*) v1
;
4755 const u32
*d2
= (const u32
*) v2
;
4757 const uint dgst_pos0
= data
.dgst_pos0
;
4758 const uint dgst_pos1
= data
.dgst_pos1
;
4759 const uint dgst_pos2
= data
.dgst_pos2
;
4760 const uint dgst_pos3
= data
.dgst_pos3
;
4762 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4763 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4764 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4765 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4766 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4767 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4768 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4769 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4774 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4776 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4777 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4779 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4781 if (res1
!= 0) return (res1
);
4786 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4788 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4789 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4791 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4793 if (res1
!= 0) return (res1
);
4795 const int res2
= t1
->attack_mode
4798 if (res2
!= 0) return (res2
);
4800 const int res3
= t1
->hash_type
4803 if (res3
!= 0) return (res3
);
4808 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4810 uint outfile_autohex
= data
.outfile_autohex
;
4812 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4814 FILE *debug_fp
= NULL
;
4816 if (debug_file
!= NULL
)
4818 debug_fp
= fopen (debug_file
, "ab");
4820 lock_file (debug_fp
);
4827 if (debug_fp
== NULL
)
4829 log_info ("WARNING: Could not open debug-file for writing");
4833 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4835 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4837 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4840 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4842 if (debug_mode
== 4)
4844 fputc (':', debug_fp
);
4846 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4849 fputc ('\n', debug_fp
);
4851 if (debug_file
!= NULL
) fclose (debug_fp
);
4855 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4857 int needs_hexify
= 0;
4859 if (outfile_autohex
== 1)
4861 for (uint i
= 0; i
< plain_len
; i
++)
4863 if (plain_ptr
[i
] < 0x20)
4870 if (plain_ptr
[i
] > 0x7f)
4879 if (needs_hexify
== 1)
4881 fprintf (fp
, "$HEX[");
4883 for (uint i
= 0; i
< plain_len
; i
++)
4885 fprintf (fp
, "%02x", plain_ptr
[i
]);
4892 fwrite (plain_ptr
, plain_len
, 1, fp
);
4896 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4898 uint outfile_format
= data
.outfile_format
;
4900 char separator
= data
.separator
;
4902 if (outfile_format
& OUTFILE_FMT_HASH
)
4904 fprintf (out_fp
, "%s", out_buf
);
4906 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4908 fputc (separator
, out_fp
);
4911 else if (data
.username
)
4913 if (username
!= NULL
)
4915 for (uint i
= 0; i
< user_len
; i
++)
4917 fprintf (out_fp
, "%c", username
[i
]);
4920 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4922 fputc (separator
, out_fp
);
4927 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4929 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4931 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4933 fputc (separator
, out_fp
);
4937 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4939 for (uint i
= 0; i
< plain_len
; i
++)
4941 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4944 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4946 fputc (separator
, out_fp
);
4950 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4953 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4958 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4960 fprintf (out_fp
, "%llu", crackpos
);
4965 fputc ('\n', out_fp
);
4968 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4972 pot_key
.hash
.salt
= hashes_buf
->salt
;
4973 pot_key
.hash
.digest
= hashes_buf
->digest
;
4975 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4981 input_buf
[input_len
] = 0;
4984 unsigned char *username
= NULL
;
4989 user_t
*user
= hashes_buf
->hash_info
->user
;
4993 username
= (unsigned char *) (user
->user_name
);
4995 user_len
= user
->user_len
;
4999 // do output the line
5000 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5004 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5005 #define LM_MASKED_PLAIN "[notfound]"
5007 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5013 pot_left_key
.hash
.salt
= hash_left
->salt
;
5014 pot_left_key
.hash
.digest
= hash_left
->digest
;
5016 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5020 uint weak_hash_found
= 0;
5022 pot_t pot_right_key
;
5024 pot_right_key
.hash
.salt
= hash_right
->salt
;
5025 pot_right_key
.hash
.digest
= hash_right
->digest
;
5027 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5029 if (pot_right_ptr
== NULL
)
5031 // special case, if "weak hash"
5033 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5035 weak_hash_found
= 1;
5037 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5039 // in theory this is not needed, but we are paranoia:
5041 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5042 pot_right_ptr
->plain_len
= 0;
5046 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5048 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5053 // at least one half was found:
5057 input_buf
[input_len
] = 0;
5061 unsigned char *username
= NULL
;
5066 user_t
*user
= hash_left
->hash_info
->user
;
5070 username
= (unsigned char *) (user
->user_name
);
5072 user_len
= user
->user_len
;
5076 // mask the part which was not found
5078 uint left_part_masked
= 0;
5079 uint right_part_masked
= 0;
5081 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5083 if (pot_left_ptr
== NULL
)
5085 left_part_masked
= 1;
5087 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5089 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5091 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5092 pot_left_ptr
->plain_len
= mask_plain_len
;
5095 if (pot_right_ptr
== NULL
)
5097 right_part_masked
= 1;
5099 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5101 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5103 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5104 pot_right_ptr
->plain_len
= mask_plain_len
;
5107 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5111 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5113 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5115 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5117 // do output the line
5119 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5121 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5123 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5124 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5127 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5131 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5133 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5135 if (pot_ptr
== NULL
)
5139 input_buf
[input_len
] = 0;
5141 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5145 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5151 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5153 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5157 pot_t pot_right_key
;
5159 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5161 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5163 uint weak_hash_found
= 0;
5165 if (pot_right_ptr
== NULL
)
5167 // special case, if "weak hash"
5169 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5171 weak_hash_found
= 1;
5173 // we just need that pot_right_ptr is not a NULL pointer
5175 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5179 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5181 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5186 // ... at least one part was not cracked
5190 input_buf
[input_len
] = 0;
5192 // only show the hash part which is still not cracked
5194 uint user_len
= input_len
- 32;
5196 char *hash_output
= (char *) mymalloc (33);
5198 memcpy (hash_output
, input_buf
, input_len
);
5200 if (pot_left_ptr
!= NULL
)
5202 // only show right part (because left part was already found)
5204 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5206 hash_output
[user_len
+ 16] = 0;
5209 if (pot_right_ptr
!= NULL
)
5211 // only show left part (because right part was already found)
5213 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5215 hash_output
[user_len
+ 16] = 0;
5218 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5220 myfree (hash_output
);
5222 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5225 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5227 uint opencl_platforms_filter
= 0;
5229 if (opencl_platforms
)
5231 char *platforms
= strdup (opencl_platforms
);
5233 char *next
= strtok (platforms
, ",");
5237 int platform
= atoi (next
);
5239 if (platform
< 1 || platform
> 32)
5241 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5246 opencl_platforms_filter
|= 1 << (platform
- 1);
5248 } while ((next
= strtok (NULL
, ",")) != NULL
);
5254 opencl_platforms_filter
= -1;
5257 return opencl_platforms_filter
;
5260 u32
setup_devices_filter (char *opencl_devices
)
5262 u32 devices_filter
= 0;
5266 char *devices
= strdup (opencl_devices
);
5268 char *next
= strtok (devices
, ",");
5272 int device_id
= atoi (next
);
5274 if (device_id
< 1 || device_id
> 32)
5276 log_error ("ERROR: invalid device_id %u specified", device_id
);
5281 devices_filter
|= 1 << (device_id
- 1);
5283 } while ((next
= strtok (NULL
, ",")) != NULL
);
5289 devices_filter
= -1;
5292 return devices_filter
;
5295 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5297 cl_device_type device_types_filter
= 0;
5299 if (opencl_device_types
)
5301 char *device_types
= strdup (opencl_device_types
);
5303 char *next
= strtok (device_types
, ",");
5307 int device_type
= atoi (next
);
5309 if (device_type
< 1 || device_type
> 3)
5311 log_error ("ERROR: invalid device_type %u specified", device_type
);
5316 device_types_filter
|= 1 << device_type
;
5318 } while ((next
= strtok (NULL
, ",")) != NULL
);
5320 free (device_types
);
5324 // Do not use CPU by default, this often reduces GPU performance because
5325 // the CPU is too busy to handle GPU synchronization
5327 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5330 return device_types_filter
;
5333 u32
get_random_num (const u32 min
, const u32 max
)
5335 if (min
== max
) return (min
);
5337 return ((rand () % (max
- min
)) + min
);
5340 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5342 u32 quotient
= dividend
/ divisor
;
5344 if (dividend
% divisor
) quotient
++;
5349 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5351 u64 quotient
= dividend
/ divisor
;
5353 if (dividend
% divisor
) quotient
++;
5358 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5360 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5361 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5363 if (tm
->tm_year
- 70)
5365 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5366 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5368 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5370 else if (tm
->tm_yday
)
5372 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5373 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5375 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5377 else if (tm
->tm_hour
)
5379 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5380 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5382 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5384 else if (tm
->tm_min
)
5386 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5387 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5389 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5393 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5395 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5399 void format_speed_display (float val
, char *buf
, size_t len
)
5410 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5421 /* generate output */
5425 snprintf (buf
, len
- 1, "%.0f ", val
);
5429 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5433 void lowercase (u8
*buf
, int len
)
5435 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5438 void uppercase (u8
*buf
, int len
)
5440 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5443 int fgetl (FILE *fp
, char *line_buf
)
5449 const int c
= fgetc (fp
);
5451 if (c
== EOF
) break;
5453 line_buf
[line_len
] = (char) c
;
5457 if (line_len
== HCBUFSIZ
) line_len
--;
5459 if (c
== '\n') break;
5462 if (line_len
== 0) return 0;
5464 if (line_buf
[line_len
- 1] == '\n')
5468 line_buf
[line_len
] = 0;
5471 if (line_len
== 0) return 0;
5473 if (line_buf
[line_len
- 1] == '\r')
5477 line_buf
[line_len
] = 0;
5483 int in_superchop (char *buf
)
5485 int len
= strlen (buf
);
5489 if (buf
[len
- 1] == '\n')
5496 if (buf
[len
- 1] == '\r')
5511 char **scan_directory (const char *path
)
5513 char *tmp_path
= mystrdup (path
);
5515 size_t tmp_path_len
= strlen (tmp_path
);
5517 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5519 tmp_path
[tmp_path_len
- 1] = 0;
5521 tmp_path_len
= strlen (tmp_path
);
5524 char **files
= NULL
;
5530 if ((d
= opendir (tmp_path
)) != NULL
)
5536 memset (&e
, 0, sizeof (e
));
5537 struct dirent
*de
= NULL
;
5539 if (readdir_r (d
, &e
, &de
) != 0)
5541 log_error ("ERROR: readdir_r() failed");
5546 if (de
== NULL
) break;
5550 while ((de
= readdir (d
)) != NULL
)
5553 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5555 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5557 char *path_file
= (char *) mymalloc (path_size
+ 1);
5559 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5561 path_file
[path_size
] = 0;
5565 if ((d_test
= opendir (path_file
)) != NULL
)
5573 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5577 files
[num_files
- 1] = path_file
;
5583 else if (errno
== ENOTDIR
)
5585 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5589 files
[num_files
- 1] = mystrdup (path
);
5592 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5596 files
[num_files
- 1] = NULL
;
5603 int count_dictionaries (char **dictionary_files
)
5605 if (dictionary_files
== NULL
) return 0;
5609 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5617 char *stroptitype (const uint opti_type
)
5621 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5622 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5623 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5624 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5625 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5626 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5627 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5628 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5629 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5630 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5631 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5632 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5633 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5634 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5635 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5636 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5637 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5638 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5639 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5645 char *strparser (const uint parser_status
)
5647 switch (parser_status
)
5649 case PARSER_OK
: return ((char *) PA_000
); break;
5650 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5651 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5652 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5653 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5654 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5655 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5656 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5657 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5658 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5659 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5660 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5661 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5662 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5663 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5664 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5665 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5668 return ((char *) PA_255
);
5671 char *strhashtype (const uint hash_mode
)
5675 case 0: return ((char *) HT_00000
); break;
5676 case 10: return ((char *) HT_00010
); break;
5677 case 11: return ((char *) HT_00011
); break;
5678 case 12: return ((char *) HT_00012
); break;
5679 case 20: return ((char *) HT_00020
); break;
5680 case 21: return ((char *) HT_00021
); break;
5681 case 22: return ((char *) HT_00022
); break;
5682 case 23: return ((char *) HT_00023
); break;
5683 case 30: return ((char *) HT_00030
); break;
5684 case 40: return ((char *) HT_00040
); break;
5685 case 50: return ((char *) HT_00050
); break;
5686 case 60: return ((char *) HT_00060
); break;
5687 case 100: return ((char *) HT_00100
); break;
5688 case 101: return ((char *) HT_00101
); break;
5689 case 110: return ((char *) HT_00110
); break;
5690 case 111: return ((char *) HT_00111
); break;
5691 case 112: return ((char *) HT_00112
); break;
5692 case 120: return ((char *) HT_00120
); break;
5693 case 121: return ((char *) HT_00121
); break;
5694 case 122: return ((char *) HT_00122
); break;
5695 case 124: return ((char *) HT_00124
); break;
5696 case 125: return ((char *) HT_00125
); break;
5697 case 130: return ((char *) HT_00130
); break;
5698 case 131: return ((char *) HT_00131
); break;
5699 case 132: return ((char *) HT_00132
); break;
5700 case 133: return ((char *) HT_00133
); break;
5701 case 140: return ((char *) HT_00140
); break;
5702 case 141: return ((char *) HT_00141
); break;
5703 case 150: return ((char *) HT_00150
); break;
5704 case 160: return ((char *) HT_00160
); break;
5705 case 190: return ((char *) HT_00190
); break;
5706 case 200: return ((char *) HT_00200
); break;
5707 case 300: return ((char *) HT_00300
); break;
5708 case 400: return ((char *) HT_00400
); break;
5709 case 500: return ((char *) HT_00500
); break;
5710 case 501: return ((char *) HT_00501
); break;
5711 case 900: return ((char *) HT_00900
); break;
5712 case 910: return ((char *) HT_00910
); break;
5713 case 1000: return ((char *) HT_01000
); break;
5714 case 1100: return ((char *) HT_01100
); break;
5715 case 1400: return ((char *) HT_01400
); break;
5716 case 1410: return ((char *) HT_01410
); break;
5717 case 1420: return ((char *) HT_01420
); break;
5718 case 1421: return ((char *) HT_01421
); break;
5719 case 1430: return ((char *) HT_01430
); break;
5720 case 1440: return ((char *) HT_01440
); break;
5721 case 1441: return ((char *) HT_01441
); break;
5722 case 1450: return ((char *) HT_01450
); break;
5723 case 1460: return ((char *) HT_01460
); break;
5724 case 1500: return ((char *) HT_01500
); break;
5725 case 1600: return ((char *) HT_01600
); break;
5726 case 1700: return ((char *) HT_01700
); break;
5727 case 1710: return ((char *) HT_01710
); break;
5728 case 1711: return ((char *) HT_01711
); break;
5729 case 1720: return ((char *) HT_01720
); break;
5730 case 1722: return ((char *) HT_01722
); break;
5731 case 1730: return ((char *) HT_01730
); break;
5732 case 1731: return ((char *) HT_01731
); break;
5733 case 1740: return ((char *) HT_01740
); break;
5734 case 1750: return ((char *) HT_01750
); break;
5735 case 1760: return ((char *) HT_01760
); break;
5736 case 1800: return ((char *) HT_01800
); break;
5737 case 2100: return ((char *) HT_02100
); break;
5738 case 2400: return ((char *) HT_02400
); break;
5739 case 2410: return ((char *) HT_02410
); break;
5740 case 2500: return ((char *) HT_02500
); break;
5741 case 2600: return ((char *) HT_02600
); break;
5742 case 2611: return ((char *) HT_02611
); break;
5743 case 2612: return ((char *) HT_02612
); break;
5744 case 2711: return ((char *) HT_02711
); break;
5745 case 2811: return ((char *) HT_02811
); break;
5746 case 3000: return ((char *) HT_03000
); break;
5747 case 3100: return ((char *) HT_03100
); break;
5748 case 3200: return ((char *) HT_03200
); break;
5749 case 3710: return ((char *) HT_03710
); break;
5750 case 3711: return ((char *) HT_03711
); break;
5751 case 3800: return ((char *) HT_03800
); break;
5752 case 4300: return ((char *) HT_04300
); break;
5753 case 4400: return ((char *) HT_04400
); break;
5754 case 4500: return ((char *) HT_04500
); break;
5755 case 4700: return ((char *) HT_04700
); break;
5756 case 4800: return ((char *) HT_04800
); break;
5757 case 4900: return ((char *) HT_04900
); break;
5758 case 5000: return ((char *) HT_05000
); break;
5759 case 5100: return ((char *) HT_05100
); break;
5760 case 5200: return ((char *) HT_05200
); break;
5761 case 5300: return ((char *) HT_05300
); break;
5762 case 5400: return ((char *) HT_05400
); break;
5763 case 5500: return ((char *) HT_05500
); break;
5764 case 5600: return ((char *) HT_05600
); break;
5765 case 5700: return ((char *) HT_05700
); break;
5766 case 5800: return ((char *) HT_05800
); break;
5767 case 6000: return ((char *) HT_06000
); break;
5768 case 6100: return ((char *) HT_06100
); break;
5769 case 6211: return ((char *) HT_06211
); break;
5770 case 6212: return ((char *) HT_06212
); break;
5771 case 6213: return ((char *) HT_06213
); break;
5772 case 6221: return ((char *) HT_06221
); break;
5773 case 6222: return ((char *) HT_06222
); break;
5774 case 6223: return ((char *) HT_06223
); break;
5775 case 6231: return ((char *) HT_06231
); break;
5776 case 6232: return ((char *) HT_06232
); break;
5777 case 6233: return ((char *) HT_06233
); break;
5778 case 6241: return ((char *) HT_06241
); break;
5779 case 6242: return ((char *) HT_06242
); break;
5780 case 6243: return ((char *) HT_06243
); break;
5781 case 6300: return ((char *) HT_06300
); break;
5782 case 6400: return ((char *) HT_06400
); break;
5783 case 6500: return ((char *) HT_06500
); break;
5784 case 6600: return ((char *) HT_06600
); break;
5785 case 6700: return ((char *) HT_06700
); break;
5786 case 6800: return ((char *) HT_06800
); break;
5787 case 6900: return ((char *) HT_06900
); break;
5788 case 7100: return ((char *) HT_07100
); break;
5789 case 7200: return ((char *) HT_07200
); break;
5790 case 7300: return ((char *) HT_07300
); break;
5791 case 7400: return ((char *) HT_07400
); break;
5792 case 7500: return ((char *) HT_07500
); break;
5793 case 7600: return ((char *) HT_07600
); break;
5794 case 7700: return ((char *) HT_07700
); break;
5795 case 7800: return ((char *) HT_07800
); break;
5796 case 7900: return ((char *) HT_07900
); break;
5797 case 8000: return ((char *) HT_08000
); break;
5798 case 8100: return ((char *) HT_08100
); break;
5799 case 8200: return ((char *) HT_08200
); break;
5800 case 8300: return ((char *) HT_08300
); break;
5801 case 8400: return ((char *) HT_08400
); break;
5802 case 8500: return ((char *) HT_08500
); break;
5803 case 8600: return ((char *) HT_08600
); break;
5804 case 8700: return ((char *) HT_08700
); break;
5805 case 8800: return ((char *) HT_08800
); break;
5806 case 8900: return ((char *) HT_08900
); break;
5807 case 9000: return ((char *) HT_09000
); break;
5808 case 9100: return ((char *) HT_09100
); break;
5809 case 9200: return ((char *) HT_09200
); break;
5810 case 9300: return ((char *) HT_09300
); break;
5811 case 9400: return ((char *) HT_09400
); break;
5812 case 9500: return ((char *) HT_09500
); break;
5813 case 9600: return ((char *) HT_09600
); break;
5814 case 9700: return ((char *) HT_09700
); break;
5815 case 9710: return ((char *) HT_09710
); break;
5816 case 9720: return ((char *) HT_09720
); break;
5817 case 9800: return ((char *) HT_09800
); break;
5818 case 9810: return ((char *) HT_09810
); break;
5819 case 9820: return ((char *) HT_09820
); break;
5820 case 9900: return ((char *) HT_09900
); break;
5821 case 10000: return ((char *) HT_10000
); break;
5822 case 10100: return ((char *) HT_10100
); break;
5823 case 10200: return ((char *) HT_10200
); break;
5824 case 10300: return ((char *) HT_10300
); break;
5825 case 10400: return ((char *) HT_10400
); break;
5826 case 10410: return ((char *) HT_10410
); break;
5827 case 10420: return ((char *) HT_10420
); break;
5828 case 10500: return ((char *) HT_10500
); break;
5829 case 10600: return ((char *) HT_10600
); break;
5830 case 10700: return ((char *) HT_10700
); break;
5831 case 10800: return ((char *) HT_10800
); break;
5832 case 10900: return ((char *) HT_10900
); break;
5833 case 11000: return ((char *) HT_11000
); break;
5834 case 11100: return ((char *) HT_11100
); break;
5835 case 11200: return ((char *) HT_11200
); break;
5836 case 11300: return ((char *) HT_11300
); break;
5837 case 11400: return ((char *) HT_11400
); break;
5838 case 11500: return ((char *) HT_11500
); break;
5839 case 11600: return ((char *) HT_11600
); break;
5840 case 11700: return ((char *) HT_11700
); break;
5841 case 11800: return ((char *) HT_11800
); break;
5842 case 11900: return ((char *) HT_11900
); break;
5843 case 12000: return ((char *) HT_12000
); break;
5844 case 12100: return ((char *) HT_12100
); break;
5845 case 12200: return ((char *) HT_12200
); break;
5846 case 12300: return ((char *) HT_12300
); break;
5847 case 12400: return ((char *) HT_12400
); break;
5848 case 12500: return ((char *) HT_12500
); break;
5849 case 12600: return ((char *) HT_12600
); break;
5850 case 12700: return ((char *) HT_12700
); break;
5851 case 12800: return ((char *) HT_12800
); break;
5852 case 12900: return ((char *) HT_12900
); break;
5853 case 13000: return ((char *) HT_13000
); break;
5854 case 13100: return ((char *) HT_13100
); break;
5855 case 13200: return ((char *) HT_13200
); break;
5856 case 13300: return ((char *) HT_13300
); break;
5857 case 13400: return ((char *) HT_13400
); break;
5858 case 13500: return ((char *) HT_13500
); break;
5861 return ((char *) "Unknown");
5864 char *strstatus (const uint devices_status
)
5866 switch (devices_status
)
5868 case STATUS_INIT
: return ((char *) ST_0000
); break;
5869 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5870 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5871 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5872 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5873 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5874 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5875 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5876 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5877 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5878 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5881 return ((char *) "Unknown");
5884 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5886 uint hash_type
= data
.hash_type
;
5887 uint hash_mode
= data
.hash_mode
;
5888 uint salt_type
= data
.salt_type
;
5889 uint opts_type
= data
.opts_type
;
5890 uint opti_type
= data
.opti_type
;
5891 uint dgst_size
= data
.dgst_size
;
5893 char *hashfile
= data
.hashfile
;
5897 uint digest_buf
[64] = { 0 };
5899 u64
*digest_buf64
= (u64
*) digest_buf
;
5901 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5903 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5905 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5911 case HASH_TYPE_DESCRYPT
:
5912 FP (digest_buf
[1], digest_buf
[0], tt
);
5915 case HASH_TYPE_DESRACF
:
5916 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5917 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5919 FP (digest_buf
[1], digest_buf
[0], tt
);
5923 FP (digest_buf
[1], digest_buf
[0], tt
);
5926 case HASH_TYPE_NETNTLM
:
5927 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5928 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5929 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5930 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5932 FP (digest_buf
[1], digest_buf
[0], tt
);
5933 FP (digest_buf
[3], digest_buf
[2], tt
);
5936 case HASH_TYPE_BSDICRYPT
:
5937 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5938 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5940 FP (digest_buf
[1], digest_buf
[0], tt
);
5945 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5950 digest_buf
[0] += MD4M_A
;
5951 digest_buf
[1] += MD4M_B
;
5952 digest_buf
[2] += MD4M_C
;
5953 digest_buf
[3] += MD4M_D
;
5957 digest_buf
[0] += MD5M_A
;
5958 digest_buf
[1] += MD5M_B
;
5959 digest_buf
[2] += MD5M_C
;
5960 digest_buf
[3] += MD5M_D
;
5963 case HASH_TYPE_SHA1
:
5964 digest_buf
[0] += SHA1M_A
;
5965 digest_buf
[1] += SHA1M_B
;
5966 digest_buf
[2] += SHA1M_C
;
5967 digest_buf
[3] += SHA1M_D
;
5968 digest_buf
[4] += SHA1M_E
;
5971 case HASH_TYPE_SHA256
:
5972 digest_buf
[0] += SHA256M_A
;
5973 digest_buf
[1] += SHA256M_B
;
5974 digest_buf
[2] += SHA256M_C
;
5975 digest_buf
[3] += SHA256M_D
;
5976 digest_buf
[4] += SHA256M_E
;
5977 digest_buf
[5] += SHA256M_F
;
5978 digest_buf
[6] += SHA256M_G
;
5979 digest_buf
[7] += SHA256M_H
;
5982 case HASH_TYPE_SHA384
:
5983 digest_buf64
[0] += SHA384M_A
;
5984 digest_buf64
[1] += SHA384M_B
;
5985 digest_buf64
[2] += SHA384M_C
;
5986 digest_buf64
[3] += SHA384M_D
;
5987 digest_buf64
[4] += SHA384M_E
;
5988 digest_buf64
[5] += SHA384M_F
;
5989 digest_buf64
[6] += 0;
5990 digest_buf64
[7] += 0;
5993 case HASH_TYPE_SHA512
:
5994 digest_buf64
[0] += SHA512M_A
;
5995 digest_buf64
[1] += SHA512M_B
;
5996 digest_buf64
[2] += SHA512M_C
;
5997 digest_buf64
[3] += SHA512M_D
;
5998 digest_buf64
[4] += SHA512M_E
;
5999 digest_buf64
[5] += SHA512M_F
;
6000 digest_buf64
[6] += SHA512M_G
;
6001 digest_buf64
[7] += SHA512M_H
;
6006 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6008 if (dgst_size
== DGST_SIZE_4_2
)
6010 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6012 else if (dgst_size
== DGST_SIZE_4_4
)
6014 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6016 else if (dgst_size
== DGST_SIZE_4_5
)
6018 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6020 else if (dgst_size
== DGST_SIZE_4_6
)
6022 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6024 else if (dgst_size
== DGST_SIZE_4_8
)
6026 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6028 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6030 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6032 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6034 else if (hash_type
== HASH_TYPE_SHA384
)
6036 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6038 else if (hash_type
== HASH_TYPE_SHA512
)
6040 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6042 else if (hash_type
== HASH_TYPE_GOST
)
6044 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6047 else if (dgst_size
== DGST_SIZE_4_64
)
6049 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6051 else if (dgst_size
== DGST_SIZE_8_25
)
6053 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6057 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6058 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6059 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6065 memset (&salt
, 0, sizeof (salt_t
));
6067 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6069 char *ptr
= (char *) salt
.salt_buf
;
6071 uint len
= salt
.salt_len
;
6073 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6079 case HASH_TYPE_NETNTLM
:
6081 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6082 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6084 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6090 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6092 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6100 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6102 uint max
= salt
.salt_len
/ 4;
6106 for (uint i
= 0; i
< max
; i
++)
6108 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6112 if (opts_type
& OPTS_TYPE_ST_HEX
)
6114 char tmp
[64] = { 0 };
6116 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6118 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6123 memcpy (ptr
, tmp
, len
);
6126 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6128 memset (ptr
+ len
, 0, memset_size
);
6130 salt
.salt_len
= len
;
6134 // some modes require special encoding
6137 uint out_buf_plain
[256] = { 0 };
6138 uint out_buf_salt
[256] = { 0 };
6140 char tmp_buf
[1024] = { 0 };
6142 char *ptr_plain
= (char *) out_buf_plain
;
6143 char *ptr_salt
= (char *) out_buf_salt
;
6145 if (hash_mode
== 22)
6147 char username
[30] = { 0 };
6149 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6151 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6153 u16
*ptr
= (u16
*) digest_buf
;
6155 tmp_buf
[ 0] = sig
[0];
6156 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6157 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6158 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6159 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6160 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6161 tmp_buf
[ 6] = sig
[1];
6162 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6163 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6164 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6165 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6166 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6167 tmp_buf
[12] = sig
[2];
6168 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6169 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6170 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6171 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6172 tmp_buf
[17] = sig
[3];
6173 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6174 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6175 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6176 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6177 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6178 tmp_buf
[23] = sig
[4];
6179 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6180 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6181 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6182 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6183 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6184 tmp_buf
[29] = sig
[5];
6186 snprintf (out_buf
, len
-1, "%s:%s",
6190 else if (hash_mode
== 23)
6192 // do not show the skyper part in output
6194 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6196 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6198 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6205 else if (hash_mode
== 101)
6207 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6209 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6210 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6211 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6212 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6213 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6215 memcpy (tmp_buf
, digest_buf
, 20);
6217 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6219 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6221 else if (hash_mode
== 111)
6223 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6225 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6226 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6227 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6228 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6229 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6231 memcpy (tmp_buf
, digest_buf
, 20);
6232 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6234 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6236 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6238 else if ((hash_mode
== 122) || (hash_mode
== 125))
6240 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6241 (char *) salt
.salt_buf
,
6248 else if (hash_mode
== 124)
6250 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6251 (char *) salt
.salt_buf
,
6258 else if (hash_mode
== 131)
6260 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6261 (char *) salt
.salt_buf
,
6269 else if (hash_mode
== 132)
6271 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6272 (char *) salt
.salt_buf
,
6279 else if (hash_mode
== 133)
6281 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6283 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6284 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6285 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6286 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6287 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6289 memcpy (tmp_buf
, digest_buf
, 20);
6291 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6293 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6295 else if (hash_mode
== 141)
6297 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6299 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6301 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6303 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6305 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6306 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6307 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6308 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6309 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6311 memcpy (tmp_buf
, digest_buf
, 20);
6313 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6317 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6319 else if (hash_mode
== 400)
6321 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6323 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6324 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6325 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6326 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6328 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6330 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6332 else if (hash_mode
== 500)
6334 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6336 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6337 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6338 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6339 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6341 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6343 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6345 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6349 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6352 else if (hash_mode
== 501)
6354 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6356 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6357 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6359 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6361 else if (hash_mode
== 1421)
6363 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6365 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6381 else if (hash_mode
== 1441)
6383 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6385 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6387 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6389 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6391 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6392 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6393 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6394 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6395 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6396 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6397 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6398 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6400 memcpy (tmp_buf
, digest_buf
, 32);
6402 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6406 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6408 else if (hash_mode
== 1500)
6410 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6411 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6412 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6413 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6414 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6416 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6418 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6420 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6421 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6423 memcpy (tmp_buf
, digest_buf
, 8);
6425 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6427 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6431 else if (hash_mode
== 1600)
6433 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6435 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6436 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6437 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6438 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6440 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6442 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6444 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6448 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6451 else if (hash_mode
== 1711)
6453 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6455 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6456 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6457 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6458 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6459 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6460 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6461 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6462 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6464 memcpy (tmp_buf
, digest_buf
, 64);
6465 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6467 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6469 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6471 else if (hash_mode
== 1722)
6473 uint
*ptr
= digest_buf
;
6475 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6476 (unsigned char *) salt
.salt_buf
,
6486 else if (hash_mode
== 1731)
6488 uint
*ptr
= digest_buf
;
6490 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6491 (unsigned char *) salt
.salt_buf
,
6501 else if (hash_mode
== 1800)
6505 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6506 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6507 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6508 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6509 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6510 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6511 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6512 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6514 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6516 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6518 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6522 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6525 else if (hash_mode
== 2100)
6529 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6531 salt
.salt_iter
+ 1);
6533 uint signature_len
= strlen (out_buf
);
6535 pos
+= signature_len
;
6536 len
-= signature_len
;
6538 char *salt_ptr
= (char *) salt
.salt_buf
;
6540 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6542 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6543 byte_swap_32 (digest_buf
[0]),
6544 byte_swap_32 (digest_buf
[1]),
6545 byte_swap_32 (digest_buf
[2]),
6546 byte_swap_32 (digest_buf
[3]));
6548 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6550 memcpy (tmp_buf
, digest_buf
, 16);
6552 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6554 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6555 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6556 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6557 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6559 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6560 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6561 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6562 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6564 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6565 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6566 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6567 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6569 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6570 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6571 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6572 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6574 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6575 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6576 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6577 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6581 else if (hash_mode
== 2500)
6583 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6585 wpa_t
*wpa
= &wpas
[salt_pos
];
6587 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6588 (char *) salt
.salt_buf
,
6602 else if (hash_mode
== 4400)
6604 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6605 byte_swap_32 (digest_buf
[0]),
6606 byte_swap_32 (digest_buf
[1]),
6607 byte_swap_32 (digest_buf
[2]),
6608 byte_swap_32 (digest_buf
[3]));
6610 else if (hash_mode
== 4700)
6612 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6613 byte_swap_32 (digest_buf
[0]),
6614 byte_swap_32 (digest_buf
[1]),
6615 byte_swap_32 (digest_buf
[2]),
6616 byte_swap_32 (digest_buf
[3]),
6617 byte_swap_32 (digest_buf
[4]));
6619 else if (hash_mode
== 4800)
6621 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6623 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6628 byte_swap_32 (salt
.salt_buf
[0]),
6629 byte_swap_32 (salt
.salt_buf
[1]),
6630 byte_swap_32 (salt
.salt_buf
[2]),
6631 byte_swap_32 (salt
.salt_buf
[3]),
6634 else if (hash_mode
== 4900)
6636 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6637 byte_swap_32 (digest_buf
[0]),
6638 byte_swap_32 (digest_buf
[1]),
6639 byte_swap_32 (digest_buf
[2]),
6640 byte_swap_32 (digest_buf
[3]),
6641 byte_swap_32 (digest_buf
[4]));
6643 else if (hash_mode
== 5100)
6645 snprintf (out_buf
, len
-1, "%08x%08x",
6649 else if (hash_mode
== 5200)
6651 snprintf (out_buf
, len
-1, "%s", hashfile
);
6653 else if (hash_mode
== 5300)
6655 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6657 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6659 int buf_len
= len
-1;
6663 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6665 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6667 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6669 snprintf (out_buf
, buf_len
, ":");
6675 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6683 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6685 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6687 if ((i
== 0) || (i
== 5))
6689 snprintf (out_buf
, buf_len
, ":");
6695 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6703 for (uint i
= 0; i
< 4; i
++)
6707 snprintf (out_buf
, buf_len
, ":");
6713 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6719 else if (hash_mode
== 5400)
6721 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6723 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6725 int buf_len
= len
-1;
6729 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6731 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6733 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6735 snprintf (out_buf
, buf_len
, ":");
6741 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6749 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6751 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6753 if ((i
== 0) || (i
== 5))
6755 snprintf (out_buf
, buf_len
, ":");
6761 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6769 for (uint i
= 0; i
< 5; i
++)
6773 snprintf (out_buf
, buf_len
, ":");
6779 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6785 else if (hash_mode
== 5500)
6787 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6789 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6791 char user_buf
[64] = { 0 };
6792 char domain_buf
[64] = { 0 };
6793 char srvchall_buf
[1024] = { 0 };
6794 char clichall_buf
[1024] = { 0 };
6796 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6798 char *ptr
= (char *) netntlm
->userdomain_buf
;
6800 user_buf
[i
] = ptr
[j
];
6803 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6805 char *ptr
= (char *) netntlm
->userdomain_buf
;
6807 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6810 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6812 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6814 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6817 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6819 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6821 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6824 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6832 byte_swap_32 (salt
.salt_buf_pc
[0]),
6833 byte_swap_32 (salt
.salt_buf_pc
[1]),
6836 else if (hash_mode
== 5600)
6838 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6840 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6842 char user_buf
[64] = { 0 };
6843 char domain_buf
[64] = { 0 };
6844 char srvchall_buf
[1024] = { 0 };
6845 char clichall_buf
[1024] = { 0 };
6847 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6849 char *ptr
= (char *) netntlm
->userdomain_buf
;
6851 user_buf
[i
] = ptr
[j
];
6854 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6856 char *ptr
= (char *) netntlm
->userdomain_buf
;
6858 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6861 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6863 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6865 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6868 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6870 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6872 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6875 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6885 else if (hash_mode
== 5700)
6887 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6889 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6890 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6891 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6892 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6893 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6894 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6895 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6896 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6898 memcpy (tmp_buf
, digest_buf
, 32);
6900 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6904 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6906 else if (hash_mode
== 5800)
6908 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6909 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6910 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6911 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6912 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6914 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6921 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6923 snprintf (out_buf
, len
-1, "%s", hashfile
);
6925 else if (hash_mode
== 6300)
6927 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6929 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6930 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6931 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6932 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6934 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6936 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6938 else if (hash_mode
== 6400)
6940 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6942 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6944 else if (hash_mode
== 6500)
6946 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6948 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6950 else if (hash_mode
== 6600)
6952 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6954 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6956 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6957 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6959 uint buf_len
= len
- 1;
6961 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6964 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6966 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6971 else if (hash_mode
== 6700)
6973 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6975 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6977 else if (hash_mode
== 6800)
6979 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6981 else if (hash_mode
== 7100)
6983 uint
*ptr
= digest_buf
;
6985 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6987 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6989 uint esalt
[8] = { 0 };
6991 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6992 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6993 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6994 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6995 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6996 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6997 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6998 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7000 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",
7001 SIGNATURE_SHA512OSX
,
7003 esalt
[ 0], esalt
[ 1],
7004 esalt
[ 2], esalt
[ 3],
7005 esalt
[ 4], esalt
[ 5],
7006 esalt
[ 6], esalt
[ 7],
7014 ptr
[15], ptr
[14]);
7016 else if (hash_mode
== 7200)
7018 uint
*ptr
= digest_buf
;
7020 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7022 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7026 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7028 len_used
= strlen (out_buf
);
7030 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7032 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7034 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7037 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",
7045 ptr
[15], ptr
[14]);
7047 else if (hash_mode
== 7300)
7049 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7051 rakp_t
*rakp
= &rakps
[salt_pos
];
7053 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7055 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7058 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7065 else if (hash_mode
== 7400)
7067 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7073 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7074 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7075 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7076 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7078 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7080 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7082 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7086 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7089 else if (hash_mode
== 7500)
7091 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7093 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7095 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7096 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7098 char data
[128] = { 0 };
7100 char *ptr_data
= data
;
7102 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7104 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7107 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7109 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7114 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7116 (char *) krb5pa
->user
,
7117 (char *) krb5pa
->realm
,
7118 (char *) krb5pa
->salt
,
7121 else if (hash_mode
== 7700)
7123 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7124 (char *) salt
.salt_buf
,
7128 else if (hash_mode
== 7800)
7130 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7131 (char *) salt
.salt_buf
,
7138 else if (hash_mode
== 7900)
7140 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7144 char *tmp
= (char *) salt
.salt_buf_pc
;
7146 ptr_plain
[42] = tmp
[0];
7152 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7154 else if (hash_mode
== 8000)
7156 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7157 (unsigned char *) salt
.salt_buf
,
7167 else if (hash_mode
== 8100)
7169 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7170 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7172 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7173 (unsigned char *) salt
.salt_buf
,
7180 else if (hash_mode
== 8200)
7182 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7184 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7186 char data_buf
[4096] = { 0 };
7188 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7190 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7193 data_buf
[cloudkey
->data_len
* 2] = 0;
7195 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7196 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7197 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7198 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7199 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7200 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7201 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7202 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7204 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7205 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7206 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7207 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7209 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7225 else if (hash_mode
== 8300)
7227 char digest_buf_c
[34] = { 0 };
7229 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7230 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7231 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7232 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7233 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7235 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7237 digest_buf_c
[32] = 0;
7241 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7243 char domain_buf_c
[33] = { 0 };
7245 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7247 for (uint i
= 0; i
< salt_pc_len
; i
++)
7249 const char next
= domain_buf_c
[i
];
7251 domain_buf_c
[i
] = '.';
7256 domain_buf_c
[salt_pc_len
] = 0;
7260 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7262 else if (hash_mode
== 8500)
7264 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7266 else if (hash_mode
== 2612)
7268 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7270 (char *) salt
.salt_buf
,
7276 else if (hash_mode
== 3711)
7278 char *salt_ptr
= (char *) salt
.salt_buf
;
7280 salt_ptr
[salt
.salt_len
- 1] = 0;
7282 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7283 SIGNATURE_MEDIAWIKI_B
,
7290 else if (hash_mode
== 8800)
7292 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7294 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7296 char tmp
[3073] = { 0 };
7298 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7300 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7305 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7306 SIGNATURE_ANDROIDFDE
,
7307 byte_swap_32 (salt
.salt_buf
[0]),
7308 byte_swap_32 (salt
.salt_buf
[1]),
7309 byte_swap_32 (salt
.salt_buf
[2]),
7310 byte_swap_32 (salt
.salt_buf
[3]),
7311 byte_swap_32 (digest_buf
[0]),
7312 byte_swap_32 (digest_buf
[1]),
7313 byte_swap_32 (digest_buf
[2]),
7314 byte_swap_32 (digest_buf
[3]),
7317 else if (hash_mode
== 8900)
7319 uint N
= salt
.scrypt_N
;
7320 uint r
= salt
.scrypt_r
;
7321 uint p
= salt
.scrypt_p
;
7323 char base64_salt
[32] = { 0 };
7325 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7327 memset (tmp_buf
, 0, 46);
7329 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7330 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7331 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7332 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7333 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7334 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7335 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7336 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7337 digest_buf
[8] = 0; // needed for base64_encode ()
7339 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7341 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7349 else if (hash_mode
== 9000)
7351 snprintf (out_buf
, len
-1, "%s", hashfile
);
7353 else if (hash_mode
== 9200)
7357 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7359 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7361 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7365 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7366 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7367 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7368 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7369 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7370 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7371 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7372 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7373 digest_buf
[8] = 0; // needed for base64_encode ()
7375 char tmp_buf
[64] = { 0 };
7377 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7378 tmp_buf
[43] = 0; // cut it here
7382 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7384 else if (hash_mode
== 9300)
7386 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7387 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7388 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7389 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7390 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7391 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7392 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7393 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7394 digest_buf
[8] = 0; // needed for base64_encode ()
7396 char tmp_buf
[64] = { 0 };
7398 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7399 tmp_buf
[43] = 0; // cut it here
7401 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7403 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7405 else if (hash_mode
== 9400)
7407 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7409 office2007_t
*office2007
= &office2007s
[salt_pos
];
7411 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7412 SIGNATURE_OFFICE2007
,
7415 office2007
->keySize
,
7421 office2007
->encryptedVerifier
[0],
7422 office2007
->encryptedVerifier
[1],
7423 office2007
->encryptedVerifier
[2],
7424 office2007
->encryptedVerifier
[3],
7425 office2007
->encryptedVerifierHash
[0],
7426 office2007
->encryptedVerifierHash
[1],
7427 office2007
->encryptedVerifierHash
[2],
7428 office2007
->encryptedVerifierHash
[3],
7429 office2007
->encryptedVerifierHash
[4]);
7431 else if (hash_mode
== 9500)
7433 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7435 office2010_t
*office2010
= &office2010s
[salt_pos
];
7437 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,
7443 office2010
->encryptedVerifier
[0],
7444 office2010
->encryptedVerifier
[1],
7445 office2010
->encryptedVerifier
[2],
7446 office2010
->encryptedVerifier
[3],
7447 office2010
->encryptedVerifierHash
[0],
7448 office2010
->encryptedVerifierHash
[1],
7449 office2010
->encryptedVerifierHash
[2],
7450 office2010
->encryptedVerifierHash
[3],
7451 office2010
->encryptedVerifierHash
[4],
7452 office2010
->encryptedVerifierHash
[5],
7453 office2010
->encryptedVerifierHash
[6],
7454 office2010
->encryptedVerifierHash
[7]);
7456 else if (hash_mode
== 9600)
7458 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7460 office2013_t
*office2013
= &office2013s
[salt_pos
];
7462 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,
7468 office2013
->encryptedVerifier
[0],
7469 office2013
->encryptedVerifier
[1],
7470 office2013
->encryptedVerifier
[2],
7471 office2013
->encryptedVerifier
[3],
7472 office2013
->encryptedVerifierHash
[0],
7473 office2013
->encryptedVerifierHash
[1],
7474 office2013
->encryptedVerifierHash
[2],
7475 office2013
->encryptedVerifierHash
[3],
7476 office2013
->encryptedVerifierHash
[4],
7477 office2013
->encryptedVerifierHash
[5],
7478 office2013
->encryptedVerifierHash
[6],
7479 office2013
->encryptedVerifierHash
[7]);
7481 else if (hash_mode
== 9700)
7483 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7485 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7487 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7488 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7489 byte_swap_32 (salt
.salt_buf
[0]),
7490 byte_swap_32 (salt
.salt_buf
[1]),
7491 byte_swap_32 (salt
.salt_buf
[2]),
7492 byte_swap_32 (salt
.salt_buf
[3]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7502 else if (hash_mode
== 9710)
7504 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7506 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7508 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7509 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7510 byte_swap_32 (salt
.salt_buf
[0]),
7511 byte_swap_32 (salt
.salt_buf
[1]),
7512 byte_swap_32 (salt
.salt_buf
[2]),
7513 byte_swap_32 (salt
.salt_buf
[3]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7523 else if (hash_mode
== 9720)
7525 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7527 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7529 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7531 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7532 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7533 byte_swap_32 (salt
.salt_buf
[0]),
7534 byte_swap_32 (salt
.salt_buf
[1]),
7535 byte_swap_32 (salt
.salt_buf
[2]),
7536 byte_swap_32 (salt
.salt_buf
[3]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7551 else if (hash_mode
== 9800)
7553 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7555 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7557 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7558 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7573 else if (hash_mode
== 9810)
7575 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7577 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7579 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7580 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7595 else if (hash_mode
== 9820)
7597 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7599 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7601 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7603 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7604 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7624 else if (hash_mode
== 10000)
7628 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7630 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7632 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7636 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7637 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7638 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7639 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7640 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7641 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7642 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7643 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7644 digest_buf
[8] = 0; // needed for base64_encode ()
7646 char tmp_buf
[64] = { 0 };
7648 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7652 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7654 else if (hash_mode
== 10100)
7656 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7661 byte_swap_32 (salt
.salt_buf
[0]),
7662 byte_swap_32 (salt
.salt_buf
[1]),
7663 byte_swap_32 (salt
.salt_buf
[2]),
7664 byte_swap_32 (salt
.salt_buf
[3]));
7666 else if (hash_mode
== 10200)
7668 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7670 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7674 char challenge
[100] = { 0 };
7676 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7680 char tmp_buf
[100] = { 0 };
7682 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7683 (char *) cram_md5
->user
,
7689 char response
[100] = { 0 };
7691 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7693 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7695 else if (hash_mode
== 10300)
7697 char tmp_buf
[100] = { 0 };
7699 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7700 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7702 uint tmp_len
= 20 + salt
.salt_len
;
7706 char base64_encoded
[100] = { 0 };
7708 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7710 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7712 else if (hash_mode
== 10400)
7714 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7716 pdf_t
*pdf
= &pdfs
[salt_pos
];
7718 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",
7726 byte_swap_32 (pdf
->id_buf
[0]),
7727 byte_swap_32 (pdf
->id_buf
[1]),
7728 byte_swap_32 (pdf
->id_buf
[2]),
7729 byte_swap_32 (pdf
->id_buf
[3]),
7731 byte_swap_32 (pdf
->u_buf
[0]),
7732 byte_swap_32 (pdf
->u_buf
[1]),
7733 byte_swap_32 (pdf
->u_buf
[2]),
7734 byte_swap_32 (pdf
->u_buf
[3]),
7735 byte_swap_32 (pdf
->u_buf
[4]),
7736 byte_swap_32 (pdf
->u_buf
[5]),
7737 byte_swap_32 (pdf
->u_buf
[6]),
7738 byte_swap_32 (pdf
->u_buf
[7]),
7740 byte_swap_32 (pdf
->o_buf
[0]),
7741 byte_swap_32 (pdf
->o_buf
[1]),
7742 byte_swap_32 (pdf
->o_buf
[2]),
7743 byte_swap_32 (pdf
->o_buf
[3]),
7744 byte_swap_32 (pdf
->o_buf
[4]),
7745 byte_swap_32 (pdf
->o_buf
[5]),
7746 byte_swap_32 (pdf
->o_buf
[6]),
7747 byte_swap_32 (pdf
->o_buf
[7])
7750 else if (hash_mode
== 10410)
7752 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7754 pdf_t
*pdf
= &pdfs
[salt_pos
];
7756 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",
7764 byte_swap_32 (pdf
->id_buf
[0]),
7765 byte_swap_32 (pdf
->id_buf
[1]),
7766 byte_swap_32 (pdf
->id_buf
[2]),
7767 byte_swap_32 (pdf
->id_buf
[3]),
7769 byte_swap_32 (pdf
->u_buf
[0]),
7770 byte_swap_32 (pdf
->u_buf
[1]),
7771 byte_swap_32 (pdf
->u_buf
[2]),
7772 byte_swap_32 (pdf
->u_buf
[3]),
7773 byte_swap_32 (pdf
->u_buf
[4]),
7774 byte_swap_32 (pdf
->u_buf
[5]),
7775 byte_swap_32 (pdf
->u_buf
[6]),
7776 byte_swap_32 (pdf
->u_buf
[7]),
7778 byte_swap_32 (pdf
->o_buf
[0]),
7779 byte_swap_32 (pdf
->o_buf
[1]),
7780 byte_swap_32 (pdf
->o_buf
[2]),
7781 byte_swap_32 (pdf
->o_buf
[3]),
7782 byte_swap_32 (pdf
->o_buf
[4]),
7783 byte_swap_32 (pdf
->o_buf
[5]),
7784 byte_swap_32 (pdf
->o_buf
[6]),
7785 byte_swap_32 (pdf
->o_buf
[7])
7788 else if (hash_mode
== 10420)
7790 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7792 pdf_t
*pdf
= &pdfs
[salt_pos
];
7794 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7796 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",
7804 byte_swap_32 (pdf
->id_buf
[0]),
7805 byte_swap_32 (pdf
->id_buf
[1]),
7806 byte_swap_32 (pdf
->id_buf
[2]),
7807 byte_swap_32 (pdf
->id_buf
[3]),
7809 byte_swap_32 (pdf
->u_buf
[0]),
7810 byte_swap_32 (pdf
->u_buf
[1]),
7811 byte_swap_32 (pdf
->u_buf
[2]),
7812 byte_swap_32 (pdf
->u_buf
[3]),
7813 byte_swap_32 (pdf
->u_buf
[4]),
7814 byte_swap_32 (pdf
->u_buf
[5]),
7815 byte_swap_32 (pdf
->u_buf
[6]),
7816 byte_swap_32 (pdf
->u_buf
[7]),
7818 byte_swap_32 (pdf
->o_buf
[0]),
7819 byte_swap_32 (pdf
->o_buf
[1]),
7820 byte_swap_32 (pdf
->o_buf
[2]),
7821 byte_swap_32 (pdf
->o_buf
[3]),
7822 byte_swap_32 (pdf
->o_buf
[4]),
7823 byte_swap_32 (pdf
->o_buf
[5]),
7824 byte_swap_32 (pdf
->o_buf
[6]),
7825 byte_swap_32 (pdf
->o_buf
[7]),
7833 else if (hash_mode
== 10500)
7835 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7837 pdf_t
*pdf
= &pdfs
[salt_pos
];
7839 if (pdf
->id_len
== 32)
7841 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",
7849 byte_swap_32 (pdf
->id_buf
[0]),
7850 byte_swap_32 (pdf
->id_buf
[1]),
7851 byte_swap_32 (pdf
->id_buf
[2]),
7852 byte_swap_32 (pdf
->id_buf
[3]),
7853 byte_swap_32 (pdf
->id_buf
[4]),
7854 byte_swap_32 (pdf
->id_buf
[5]),
7855 byte_swap_32 (pdf
->id_buf
[6]),
7856 byte_swap_32 (pdf
->id_buf
[7]),
7858 byte_swap_32 (pdf
->u_buf
[0]),
7859 byte_swap_32 (pdf
->u_buf
[1]),
7860 byte_swap_32 (pdf
->u_buf
[2]),
7861 byte_swap_32 (pdf
->u_buf
[3]),
7862 byte_swap_32 (pdf
->u_buf
[4]),
7863 byte_swap_32 (pdf
->u_buf
[5]),
7864 byte_swap_32 (pdf
->u_buf
[6]),
7865 byte_swap_32 (pdf
->u_buf
[7]),
7867 byte_swap_32 (pdf
->o_buf
[0]),
7868 byte_swap_32 (pdf
->o_buf
[1]),
7869 byte_swap_32 (pdf
->o_buf
[2]),
7870 byte_swap_32 (pdf
->o_buf
[3]),
7871 byte_swap_32 (pdf
->o_buf
[4]),
7872 byte_swap_32 (pdf
->o_buf
[5]),
7873 byte_swap_32 (pdf
->o_buf
[6]),
7874 byte_swap_32 (pdf
->o_buf
[7])
7879 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",
7887 byte_swap_32 (pdf
->id_buf
[0]),
7888 byte_swap_32 (pdf
->id_buf
[1]),
7889 byte_swap_32 (pdf
->id_buf
[2]),
7890 byte_swap_32 (pdf
->id_buf
[3]),
7892 byte_swap_32 (pdf
->u_buf
[0]),
7893 byte_swap_32 (pdf
->u_buf
[1]),
7894 byte_swap_32 (pdf
->u_buf
[2]),
7895 byte_swap_32 (pdf
->u_buf
[3]),
7896 byte_swap_32 (pdf
->u_buf
[4]),
7897 byte_swap_32 (pdf
->u_buf
[5]),
7898 byte_swap_32 (pdf
->u_buf
[6]),
7899 byte_swap_32 (pdf
->u_buf
[7]),
7901 byte_swap_32 (pdf
->o_buf
[0]),
7902 byte_swap_32 (pdf
->o_buf
[1]),
7903 byte_swap_32 (pdf
->o_buf
[2]),
7904 byte_swap_32 (pdf
->o_buf
[3]),
7905 byte_swap_32 (pdf
->o_buf
[4]),
7906 byte_swap_32 (pdf
->o_buf
[5]),
7907 byte_swap_32 (pdf
->o_buf
[6]),
7908 byte_swap_32 (pdf
->o_buf
[7])
7912 else if (hash_mode
== 10600)
7914 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7916 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7917 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7919 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7921 else if (hash_mode
== 10700)
7923 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7925 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7926 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7928 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7930 else if (hash_mode
== 10900)
7932 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7934 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7935 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7937 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7939 else if (hash_mode
== 11100)
7941 u32 salt_challenge
= salt
.salt_buf
[0];
7943 salt_challenge
= byte_swap_32 (salt_challenge
);
7945 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7947 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7948 SIGNATURE_POSTGRESQL_AUTH
,
7956 else if (hash_mode
== 11200)
7958 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7959 SIGNATURE_MYSQL_AUTH
,
7960 (unsigned char *) salt
.salt_buf
,
7967 else if (hash_mode
== 11300)
7969 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7971 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7973 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7974 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7975 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7977 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7978 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7979 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7981 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7983 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7985 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7988 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7990 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7992 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7995 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7997 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7999 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8002 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8003 SIGNATURE_BITCOIN_WALLET
,
8007 (unsigned char *) salt
.salt_buf
,
8015 free (cry_master_buf
);
8017 free (public_key_buf
);
8019 else if (hash_mode
== 11400)
8021 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8023 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8024 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8026 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8028 else if (hash_mode
== 11600)
8030 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8032 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8034 const uint data_len
= seven_zip
->data_len
;
8036 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8038 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8040 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8042 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8045 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8046 SIGNATURE_SEVEN_ZIP
,
8050 (char *) seven_zip
->salt_buf
,
8052 seven_zip
->iv_buf
[0],
8053 seven_zip
->iv_buf
[1],
8054 seven_zip
->iv_buf
[2],
8055 seven_zip
->iv_buf
[3],
8057 seven_zip
->data_len
,
8058 seven_zip
->unpack_size
,
8063 else if (hash_mode
== 11700)
8065 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8075 else if (hash_mode
== 11800)
8077 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8095 else if (hash_mode
== 11900)
8097 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8099 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8100 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8102 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8104 else if (hash_mode
== 12000)
8106 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8108 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8109 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8111 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8113 else if (hash_mode
== 12100)
8115 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8117 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8118 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8120 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8122 else if (hash_mode
== 12200)
8124 uint
*ptr_digest
= digest_buf
;
8125 uint
*ptr_salt
= salt
.salt_buf
;
8127 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8134 else if (hash_mode
== 12300)
8136 uint
*ptr_digest
= digest_buf
;
8137 uint
*ptr_salt
= salt
.salt_buf
;
8139 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",
8140 ptr_digest
[ 0], ptr_digest
[ 1],
8141 ptr_digest
[ 2], ptr_digest
[ 3],
8142 ptr_digest
[ 4], ptr_digest
[ 5],
8143 ptr_digest
[ 6], ptr_digest
[ 7],
8144 ptr_digest
[ 8], ptr_digest
[ 9],
8145 ptr_digest
[10], ptr_digest
[11],
8146 ptr_digest
[12], ptr_digest
[13],
8147 ptr_digest
[14], ptr_digest
[15],
8153 else if (hash_mode
== 12400)
8155 // encode iteration count
8157 char salt_iter
[5] = { 0 };
8159 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8160 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8161 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8162 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8167 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8168 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8169 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8170 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8175 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8177 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8178 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8180 memcpy (tmp_buf
, digest_buf
, 8);
8182 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8186 // fill the resulting buffer
8188 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8190 else if (hash_mode
== 12500)
8192 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8194 byte_swap_32 (salt
.salt_buf
[0]),
8195 byte_swap_32 (salt
.salt_buf
[1]),
8201 else if (hash_mode
== 12600)
8203 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8204 digest_buf
[0] + salt
.salt_buf_pc
[0],
8205 digest_buf
[1] + salt
.salt_buf_pc
[1],
8206 digest_buf
[2] + salt
.salt_buf_pc
[2],
8207 digest_buf
[3] + salt
.salt_buf_pc
[3],
8208 digest_buf
[4] + salt
.salt_buf_pc
[4],
8209 digest_buf
[5] + salt
.salt_buf_pc
[5],
8210 digest_buf
[6] + salt
.salt_buf_pc
[6],
8211 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8213 else if (hash_mode
== 12700)
8215 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8217 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8218 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8220 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8222 else if (hash_mode
== 12800)
8224 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8226 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",
8239 byte_swap_32 (digest_buf
[0]),
8240 byte_swap_32 (digest_buf
[1]),
8241 byte_swap_32 (digest_buf
[2]),
8242 byte_swap_32 (digest_buf
[3]),
8243 byte_swap_32 (digest_buf
[4]),
8244 byte_swap_32 (digest_buf
[5]),
8245 byte_swap_32 (digest_buf
[6]),
8246 byte_swap_32 (digest_buf
[7])
8249 else if (hash_mode
== 12900)
8251 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",
8260 byte_swap_32 (digest_buf
[0]),
8261 byte_swap_32 (digest_buf
[1]),
8262 byte_swap_32 (digest_buf
[2]),
8263 byte_swap_32 (digest_buf
[3]),
8264 byte_swap_32 (digest_buf
[4]),
8265 byte_swap_32 (digest_buf
[5]),
8266 byte_swap_32 (digest_buf
[6]),
8267 byte_swap_32 (digest_buf
[7]),
8274 else if (hash_mode
== 13000)
8276 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8278 rar5_t
*rar5
= &rar5s
[salt_pos
];
8280 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8290 byte_swap_32 (digest_buf
[0]),
8291 byte_swap_32 (digest_buf
[1])
8294 else if (hash_mode
== 13100)
8296 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8298 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8300 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8301 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8303 char data
[2560 * 4 * 2] = { 0 };
8305 char *ptr_data
= data
;
8307 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8308 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8313 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8314 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8316 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8318 (char *) krb5tgs
->account_info
,
8322 else if (hash_mode
== 13200)
8324 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8338 else if (hash_mode
== 13300)
8340 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8341 SIGNATURE_AXCRYPT_SHA1
,
8347 else if (hash_mode
== 13400)
8349 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8351 keepass_t
*keepass
= &keepasss
[salt_pos
];
8353 u32 version
= (u32
) keepass
->version
;
8354 u32 rounds
= salt
.salt_iter
;
8355 u32 algorithm
= (u32
) keepass
->algorithm
;
8356 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8358 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8359 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8360 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8361 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8362 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8364 /* specific to version 1 */
8368 /* specific to version 2 */
8369 u32 expected_bytes_len
;
8370 u32
*ptr_expected_bytes
;
8372 u32 final_random_seed_len
;
8373 u32 transf_random_seed_len
;
8375 u32 contents_hash_len
;
8377 transf_random_seed_len
= 8;
8379 contents_hash_len
= 8;
8380 final_random_seed_len
= 8;
8383 final_random_seed_len
= 4;
8385 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8391 char *ptr_data
= out_buf
;
8393 ptr_data
+= strlen(out_buf
);
8398 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8399 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8404 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8405 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8410 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8411 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8418 contents_len
= (u32
) keepass
->contents_len
;
8419 ptr_contents
= (u32
*) keepass
->contents
;
8421 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8422 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8434 char ptr_contents_len
[10] = { 0 };
8436 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8438 sprintf (ptr_data
, "%d", contents_len
);
8440 ptr_data
+= strlen(ptr_contents_len
);
8445 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8446 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8448 else if (version
== 2)
8450 expected_bytes_len
= 8;
8451 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8453 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8454 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8459 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8460 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8474 sprintf (ptr_data
, "%d", keyfile_len
);
8481 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8482 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8485 else if (hash_mode
== 13500)
8487 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8489 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8491 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8493 char pstoken_tmp
[1024 + 1] = { 0 };
8495 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8497 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8499 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8502 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8512 if (hash_type
== HASH_TYPE_MD4
)
8514 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8520 else if (hash_type
== HASH_TYPE_MD5
)
8522 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8528 else if (hash_type
== HASH_TYPE_SHA1
)
8530 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8537 else if (hash_type
== HASH_TYPE_SHA256
)
8539 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8549 else if (hash_type
== HASH_TYPE_SHA384
)
8551 uint
*ptr
= digest_buf
;
8553 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8561 else if (hash_type
== HASH_TYPE_SHA512
)
8563 uint
*ptr
= digest_buf
;
8565 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8575 else if (hash_type
== HASH_TYPE_LM
)
8577 snprintf (out_buf
, len
-1, "%08x%08x",
8581 else if (hash_type
== HASH_TYPE_ORACLEH
)
8583 snprintf (out_buf
, len
-1, "%08X%08X",
8587 else if (hash_type
== HASH_TYPE_BCRYPT
)
8589 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8590 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8592 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8594 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8596 else if (hash_type
== HASH_TYPE_KECCAK
)
8598 uint
*ptr
= digest_buf
;
8600 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",
8628 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8630 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8632 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8639 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8641 digest_buf
[ 0] = digest_buf
[ 0];
8642 digest_buf
[ 1] = digest_buf
[ 1];
8643 digest_buf
[ 2] = digest_buf
[ 2];
8644 digest_buf
[ 3] = digest_buf
[ 3];
8645 digest_buf
[ 4] = digest_buf
[ 4];
8646 digest_buf
[ 5] = digest_buf
[ 5];
8647 digest_buf
[ 6] = digest_buf
[ 6];
8648 digest_buf
[ 7] = digest_buf
[ 7];
8649 digest_buf
[ 8] = digest_buf
[ 8];
8650 digest_buf
[ 9] = digest_buf
[ 9];
8651 digest_buf
[10] = digest_buf
[10];
8652 digest_buf
[11] = digest_buf
[11];
8653 digest_buf
[12] = digest_buf
[12];
8654 digest_buf
[13] = digest_buf
[13];
8655 digest_buf
[14] = digest_buf
[14];
8656 digest_buf
[15] = digest_buf
[15];
8658 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8676 else if (hash_type
== HASH_TYPE_GOST
)
8678 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8688 else if (hash_type
== HASH_TYPE_MYSQL
)
8690 snprintf (out_buf
, len
-1, "%08x%08x",
8694 else if (hash_type
== HASH_TYPE_LOTUS5
)
8696 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8702 else if (hash_type
== HASH_TYPE_LOTUS6
)
8704 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8705 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8706 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8707 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8709 char buf
[16] = { 0 };
8711 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8712 memcpy (buf
+ 5, digest_buf
, 9);
8716 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8718 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8721 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8723 else if (hash_type
== HASH_TYPE_LOTUS8
)
8725 char buf
[52] = { 0 };
8729 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8735 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8739 buf
[26] = salt
.salt_buf_pc
[0];
8740 buf
[27] = salt
.salt_buf_pc
[1];
8744 memcpy (buf
+ 28, digest_buf
, 8);
8746 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8750 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8752 else if (hash_type
== HASH_TYPE_CRC32
)
8754 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8758 if (salt_type
== SALT_TYPE_INTERN
)
8760 size_t pos
= strlen (out_buf
);
8762 out_buf
[pos
] = data
.separator
;
8764 char *ptr
= (char *) salt
.salt_buf
;
8766 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8768 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8772 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8774 memset (hccap
, 0, sizeof (hccap_t
));
8776 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8778 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8780 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8781 wpa_t
*wpa
= &wpas
[salt_pos
];
8783 hccap
->keyver
= wpa
->keyver
;
8785 hccap
->eapol_size
= wpa
->eapol_size
;
8787 if (wpa
->keyver
!= 1)
8789 uint eapol_tmp
[64] = { 0 };
8791 for (uint i
= 0; i
< 64; i
++)
8793 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8796 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8800 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8803 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8804 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8805 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8806 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8808 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8810 uint dgst_size
= data
.dgst_size
;
8812 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8814 if (wpa
->keyver
!= 1)
8816 uint digest_tmp
[4] = { 0 };
8818 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8819 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8820 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8821 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8823 memcpy (hccap
->keymic
, digest_tmp
, 16);
8827 memcpy (hccap
->keymic
, digest_ptr
, 16);
8831 void SuspendThreads ()
8833 if (data
.devices_status
== STATUS_RUNNING
)
8835 hc_timer_set (&data
.timer_paused
);
8837 data
.devices_status
= STATUS_PAUSED
;
8839 log_info ("Paused");
8843 void ResumeThreads ()
8845 if (data
.devices_status
== STATUS_PAUSED
)
8849 hc_timer_get (data
.timer_paused
, ms_paused
);
8851 data
.ms_paused
+= ms_paused
;
8853 data
.devices_status
= STATUS_RUNNING
;
8855 log_info ("Resumed");
8861 if (data
.devices_status
!= STATUS_RUNNING
) return;
8863 data
.devices_status
= STATUS_BYPASS
;
8865 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8868 void stop_at_checkpoint ()
8870 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8872 if (data
.devices_status
!= STATUS_RUNNING
) return;
8875 // this feature only makes sense if --restore-disable was not specified
8877 if (data
.restore_disable
== 1)
8879 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8884 // check if monitoring of Restore Point updates should be enabled or disabled
8886 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8888 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8890 // save the current restore point value
8892 data
.checkpoint_cur_words
= get_lowest_words_done ();
8894 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8898 data
.devices_status
= STATUS_RUNNING
;
8900 // reset the global value for checkpoint checks
8902 data
.checkpoint_cur_words
= 0;
8904 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8910 if (data
.devices_status
== STATUS_INIT
) return;
8911 if (data
.devices_status
== STATUS_STARTING
) return;
8913 data
.devices_status
= STATUS_ABORTED
;
8918 if (data
.devices_status
== STATUS_INIT
) return;
8919 if (data
.devices_status
== STATUS_STARTING
) return;
8921 data
.devices_status
= STATUS_QUIT
;
8924 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8926 FILE *fp
= fopen (kernel_file
, "rb");
8932 memset (&st
, 0, sizeof (st
));
8934 stat (kernel_file
, &st
);
8936 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8938 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8940 if (num_read
!= (size_t) st
.st_size
)
8942 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8949 buf
[st
.st_size
] = 0;
8951 for (int i
= 0; i
< num_devices
; i
++)
8953 kernel_lengths
[i
] = (size_t) st
.st_size
;
8955 kernel_sources
[i
] = buf
;
8960 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8968 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8970 if (binary_size
> 0)
8972 FILE *fp
= fopen (dst
, "wb");
8975 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8986 restore_data_t
*init_restore (int argc
, char **argv
)
8988 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8990 if (data
.restore_disable
== 0)
8992 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8996 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9000 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9009 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9011 int pidbin_len
= -1;
9014 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9016 FILE *fd
= fopen (pidbin
, "rb");
9020 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9022 pidbin
[pidbin_len
] = 0;
9026 char *argv0_r
= strrchr (argv
[0], '/');
9028 char *pidbin_r
= strrchr (pidbin
, '/');
9030 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9032 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9034 if (strcmp (argv0_r
, pidbin_r
) == 0)
9036 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9043 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9045 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9047 int pidbin2_len
= -1;
9049 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9050 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9052 pidbin
[pidbin_len
] = 0;
9053 pidbin2
[pidbin2_len
] = 0;
9057 if (strcmp (pidbin
, pidbin2
) == 0)
9059 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9072 if (rd
->version_bin
< RESTORE_MIN
)
9074 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9081 memset (rd
, 0, sizeof (restore_data_t
));
9083 rd
->version_bin
= VERSION_BIN
;
9086 rd
->pid
= getpid ();
9088 rd
->pid
= GetCurrentProcessId ();
9091 if (getcwd (rd
->cwd
, 255) == NULL
)
9104 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9106 FILE *fp
= fopen (eff_restore_file
, "rb");
9110 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9115 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9117 log_error ("ERROR: cannot read %s", eff_restore_file
);
9122 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9124 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9126 for (uint i
= 0; i
< rd
->argc
; i
++)
9128 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9130 log_error ("ERROR: cannot read %s", eff_restore_file
);
9135 size_t len
= strlen (buf
);
9137 if (len
) buf
[len
- 1] = 0;
9139 rd
->argv
[i
] = mystrdup (buf
);
9146 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9148 if (chdir (rd
->cwd
))
9150 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9151 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9152 " https://github.com/philsmd/analyze_hc_restore\n"
9153 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9159 u64
get_lowest_words_done ()
9163 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9165 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9167 if (device_param
->skipped
) continue;
9169 const u64 words_done
= device_param
->words_done
;
9171 if (words_done
< words_cur
) words_cur
= words_done
;
9174 // It's possible that a device's workload isn't finished right after a restore-case.
9175 // In that case, this function would return 0 and overwrite the real restore point
9176 // There's also data.words_cur which is set to rd->words_cur but it changes while
9177 // the attack is running therefore we should stick to rd->words_cur.
9178 // Note that -s influences rd->words_cur we should keep a close look on that.
9180 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9185 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9187 u64 words_cur
= get_lowest_words_done ();
9189 rd
->words_cur
= words_cur
;
9191 FILE *fp
= fopen (new_restore_file
, "wb");
9195 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9200 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9202 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9207 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9209 for (uint i
= 0; i
< rd
->argc
; i
++)
9211 fprintf (fp
, "%s", rd
->argv
[i
]);
9217 fsync (fileno (fp
));
9222 void cycle_restore ()
9224 const char *eff_restore_file
= data
.eff_restore_file
;
9225 const char *new_restore_file
= data
.new_restore_file
;
9227 restore_data_t
*rd
= data
.rd
;
9229 write_restore (new_restore_file
, rd
);
9233 memset (&st
, 0, sizeof(st
));
9235 if (stat (eff_restore_file
, &st
) == 0)
9237 if (unlink (eff_restore_file
))
9239 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9243 if (rename (new_restore_file
, eff_restore_file
))
9245 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9249 void check_checkpoint ()
9251 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9253 u64 words_cur
= get_lowest_words_done ();
9255 if (words_cur
!= data
.checkpoint_cur_words
)
9265 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9269 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9271 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9273 myfree (alias
->device_name
);
9274 myfree (alias
->alias_name
);
9277 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9279 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9281 myfree (entry
->device_name
);
9284 myfree (tuning_db
->alias_buf
);
9285 myfree (tuning_db
->entry_buf
);
9290 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9292 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9294 int num_lines
= count_lines (fp
);
9296 // a bit over-allocated
9298 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9299 tuning_db
->alias_cnt
= 0;
9301 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9302 tuning_db
->entry_cnt
= 0;
9307 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9309 FILE *fp
= fopen (tuning_db_file
, "rb");
9313 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9318 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9324 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9328 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9330 if (line_buf
== NULL
) break;
9334 const int line_len
= in_superchop (line_buf
);
9336 if (line_len
== 0) continue;
9338 if (line_buf
[0] == '#') continue;
9342 char *token_ptr
[7] = { NULL
};
9346 char *next
= strtok (line_buf
, "\t ");
9348 token_ptr
[token_cnt
] = next
;
9352 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9354 token_ptr
[token_cnt
] = next
;
9361 char *device_name
= token_ptr
[0];
9362 char *alias_name
= token_ptr
[1];
9364 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9366 alias
->device_name
= mystrdup (device_name
);
9367 alias
->alias_name
= mystrdup (alias_name
);
9369 tuning_db
->alias_cnt
++;
9371 else if (token_cnt
== 6)
9373 if ((token_ptr
[1][0] != '0') &&
9374 (token_ptr
[1][0] != '1') &&
9375 (token_ptr
[1][0] != '3') &&
9376 (token_ptr
[1][0] != '*'))
9378 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9383 if ((token_ptr
[3][0] != '1') &&
9384 (token_ptr
[3][0] != '2') &&
9385 (token_ptr
[3][0] != '4') &&
9386 (token_ptr
[3][0] != '8') &&
9387 (token_ptr
[3][0] != 'N'))
9389 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9394 char *device_name
= token_ptr
[0];
9396 int attack_mode
= -1;
9398 int vector_width
= -1;
9399 int kernel_accel
= -1;
9400 int kernel_loops
= -1;
9402 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9403 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9404 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9406 if (token_ptr
[4][0] != 'A')
9408 kernel_accel
= atoi (token_ptr
[4]);
9410 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9412 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9422 if (token_ptr
[5][0] != 'A')
9424 kernel_loops
= atoi (token_ptr
[5]);
9426 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9428 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9438 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9440 entry
->device_name
= mystrdup (device_name
);
9441 entry
->attack_mode
= attack_mode
;
9442 entry
->hash_type
= hash_type
;
9443 entry
->vector_width
= vector_width
;
9444 entry
->kernel_accel
= kernel_accel
;
9445 entry
->kernel_loops
= kernel_loops
;
9447 tuning_db
->entry_cnt
++;
9451 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9461 // todo: print loaded 'cnt' message
9463 // sort the database
9465 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9466 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9471 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9473 static tuning_db_entry_t s
;
9475 // first we need to convert all spaces in the device_name to underscore
9477 char *device_name_nospace
= strdup (device_param
->device_name
);
9479 int device_name_length
= strlen (device_name_nospace
);
9483 for (i
= 0; i
< device_name_length
; i
++)
9485 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9488 // find out if there's an alias configured
9490 tuning_db_alias_t a
;
9492 a
.device_name
= device_name_nospace
;
9494 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
);
9496 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9498 // attack-mode 6 and 7 are attack-mode 1 basically
9500 if (attack_mode
== 6) attack_mode
= 1;
9501 if (attack_mode
== 7) attack_mode
= 1;
9503 // bsearch is not ideal but fast enough
9505 s
.device_name
= device_name_nospace
;
9506 s
.attack_mode
= attack_mode
;
9507 s
.hash_type
= hash_type
;
9509 tuning_db_entry_t
*entry
= NULL
;
9511 // this will produce all 2^3 combinations required
9513 for (i
= 0; i
< 8; i
++)
9515 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9516 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9517 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9519 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9521 if (entry
!= NULL
) break;
9523 // in non-wildcard mode do some additional checks:
9527 // in case we have an alias-name
9529 if (alias_name
!= NULL
)
9531 s
.device_name
= alias_name
;
9533 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9535 if (entry
!= NULL
) break;
9538 // or by device type
9540 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9542 s
.device_name
= "DEVICE_TYPE_CPU";
9544 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9546 s
.device_name
= "DEVICE_TYPE_GPU";
9548 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9550 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9553 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9555 if (entry
!= NULL
) break;
9559 // free converted device_name
9561 myfree (device_name_nospace
);
9570 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9572 u8 tmp
[256] = { 0 };
9574 if (salt_len
> sizeof (tmp
))
9579 memcpy (tmp
, in
, salt_len
);
9581 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9583 if ((salt_len
% 2) == 0)
9585 u32 new_salt_len
= salt_len
/ 2;
9587 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9592 tmp
[i
] = hex_convert (p1
) << 0;
9593 tmp
[i
] |= hex_convert (p0
) << 4;
9596 salt_len
= new_salt_len
;
9603 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9605 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9608 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9610 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9614 u32
*tmp_uint
= (u32
*) tmp
;
9616 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9617 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9618 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9619 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9620 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9621 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9622 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9623 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9624 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9625 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9627 salt_len
= salt_len
* 2;
9635 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9637 lowercase (tmp
, salt_len
);
9640 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9642 uppercase (tmp
, salt_len
);
9647 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9652 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9657 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9659 u32
*tmp_uint
= (uint
*) tmp
;
9665 for (u32 i
= 0; i
< max
; i
++)
9667 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9670 // Important: we may need to increase the length of memcpy since
9671 // we don't want to "loose" some swapped bytes (could happen if
9672 // they do not perfectly fit in the 4-byte blocks)
9673 // Memcpy does always copy the bytes in the BE order, but since
9674 // we swapped them, some important bytes could be in positions
9675 // we normally skip with the original len
9677 if (len
% 4) len
+= 4 - (len
% 4);
9680 memcpy (out
, tmp
, len
);
9685 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9687 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9689 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9691 u32
*digest
= (u32
*) hash_buf
->digest
;
9693 salt_t
*salt
= hash_buf
->salt
;
9695 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9697 char *iter_pos
= input_buf
+ 4;
9699 salt
->salt_iter
= 1 << atoi (iter_pos
);
9701 char *salt_pos
= strchr (iter_pos
, '$');
9703 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9709 salt
->salt_len
= salt_len
;
9711 u8 tmp_buf
[100] = { 0 };
9713 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9715 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9717 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9719 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9720 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9721 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9722 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9724 char *hash_pos
= salt_pos
+ 22;
9726 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9728 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9730 memcpy (digest
, tmp_buf
, 24);
9732 digest
[0] = byte_swap_32 (digest
[0]);
9733 digest
[1] = byte_swap_32 (digest
[1]);
9734 digest
[2] = byte_swap_32 (digest
[2]);
9735 digest
[3] = byte_swap_32 (digest
[3]);
9736 digest
[4] = byte_swap_32 (digest
[4]);
9737 digest
[5] = byte_swap_32 (digest
[5]);
9739 digest
[5] &= ~0xff; // its just 23 not 24 !
9744 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9746 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9748 u32
*digest
= (u32
*) hash_buf
->digest
;
9750 u8 tmp_buf
[100] = { 0 };
9752 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9754 memcpy (digest
, tmp_buf
, 32);
9756 digest
[0] = byte_swap_32 (digest
[0]);
9757 digest
[1] = byte_swap_32 (digest
[1]);
9758 digest
[2] = byte_swap_32 (digest
[2]);
9759 digest
[3] = byte_swap_32 (digest
[3]);
9760 digest
[4] = byte_swap_32 (digest
[4]);
9761 digest
[5] = byte_swap_32 (digest
[5]);
9762 digest
[6] = byte_swap_32 (digest
[6]);
9763 digest
[7] = byte_swap_32 (digest
[7]);
9765 digest
[0] -= SHA256M_A
;
9766 digest
[1] -= SHA256M_B
;
9767 digest
[2] -= SHA256M_C
;
9768 digest
[3] -= SHA256M_D
;
9769 digest
[4] -= SHA256M_E
;
9770 digest
[5] -= SHA256M_F
;
9771 digest
[6] -= SHA256M_G
;
9772 digest
[7] -= SHA256M_H
;
9777 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9779 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9781 u32
*digest
= (u32
*) hash_buf
->digest
;
9783 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9784 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9786 digest
[0] = byte_swap_32 (digest
[0]);
9787 digest
[1] = byte_swap_32 (digest
[1]);
9791 IP (digest
[0], digest
[1], tt
);
9793 digest
[0] = digest
[0];
9794 digest
[1] = digest
[1];
9801 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9803 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9805 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9807 u32
*digest
= (u32
*) hash_buf
->digest
;
9809 salt_t
*salt
= hash_buf
->salt
;
9811 char *hash_pos
= input_buf
+ 10;
9813 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9814 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9815 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9816 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9817 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9819 digest
[0] -= SHA1M_A
;
9820 digest
[1] -= SHA1M_B
;
9821 digest
[2] -= SHA1M_C
;
9822 digest
[3] -= SHA1M_D
;
9823 digest
[4] -= SHA1M_E
;
9827 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9829 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9831 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9833 salt
->salt_len
= salt_len
;
9838 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9840 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9842 u32
*digest
= (u32
*) hash_buf
->digest
;
9844 salt_t
*salt
= hash_buf
->salt
;
9846 char *hash_pos
= input_buf
+ 8;
9848 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9849 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9850 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9851 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9852 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9854 digest
[0] -= SHA1M_A
;
9855 digest
[1] -= SHA1M_B
;
9856 digest
[2] -= SHA1M_C
;
9857 digest
[3] -= SHA1M_D
;
9858 digest
[4] -= SHA1M_E
;
9862 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9864 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9866 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9868 salt
->salt_len
= salt_len
;
9873 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9875 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9877 u64
*digest
= (u64
*) hash_buf
->digest
;
9879 salt_t
*salt
= hash_buf
->salt
;
9881 char *hash_pos
= input_buf
+ 8;
9883 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9884 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9885 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9886 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9887 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9888 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9889 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9890 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9892 digest
[0] -= SHA512M_A
;
9893 digest
[1] -= SHA512M_B
;
9894 digest
[2] -= SHA512M_C
;
9895 digest
[3] -= SHA512M_D
;
9896 digest
[4] -= SHA512M_E
;
9897 digest
[5] -= SHA512M_F
;
9898 digest
[6] -= SHA512M_G
;
9899 digest
[7] -= SHA512M_H
;
9903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9905 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9907 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9909 salt
->salt_len
= salt_len
;
9914 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9916 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9918 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9922 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9925 u32
*digest
= (u32
*) hash_buf
->digest
;
9927 salt_t
*salt
= hash_buf
->salt
;
9929 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9930 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9931 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9932 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9934 digest
[0] = byte_swap_32 (digest
[0]);
9935 digest
[1] = byte_swap_32 (digest
[1]);
9936 digest
[2] = byte_swap_32 (digest
[2]);
9937 digest
[3] = byte_swap_32 (digest
[3]);
9939 digest
[0] -= MD5M_A
;
9940 digest
[1] -= MD5M_B
;
9941 digest
[2] -= MD5M_C
;
9942 digest
[3] -= MD5M_D
;
9944 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9946 uint salt_len
= input_len
- 32 - 1;
9948 char *salt_buf
= input_buf
+ 32 + 1;
9950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9956 salt
->salt_len
= salt_len
;
9961 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9963 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9965 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9969 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9974 char clean_input_buf
[32] = { 0 };
9976 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9977 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9979 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9983 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9989 clean_input_buf
[k
] = input_buf
[i
];
9997 u32
*digest
= (u32
*) hash_buf
->digest
;
9999 salt_t
*salt
= hash_buf
->salt
;
10001 u32 a
, b
, c
, d
, e
, f
;
10003 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10004 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10005 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10006 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10007 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10008 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10010 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10011 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10013 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10014 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10015 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10016 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10017 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10018 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10020 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10021 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10023 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10024 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10025 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10026 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10027 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10028 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10030 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10031 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10033 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10034 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10035 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10036 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10037 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10038 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10040 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10041 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10043 digest
[0] = byte_swap_32 (digest
[0]);
10044 digest
[1] = byte_swap_32 (digest
[1]);
10045 digest
[2] = byte_swap_32 (digest
[2]);
10046 digest
[3] = byte_swap_32 (digest
[3]);
10048 digest
[0] -= MD5M_A
;
10049 digest
[1] -= MD5M_B
;
10050 digest
[2] -= MD5M_C
;
10051 digest
[3] -= MD5M_D
;
10053 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10055 uint salt_len
= input_len
- 30 - 1;
10057 char *salt_buf
= input_buf
+ 30 + 1;
10059 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10061 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10063 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10064 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10066 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10068 salt
->salt_len
= salt_len
;
10070 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10072 salt
->salt_len
+= 22;
10074 return (PARSER_OK
);
10077 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10079 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10081 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10085 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10088 u32
*digest
= (u32
*) hash_buf
->digest
;
10090 salt_t
*salt
= hash_buf
->salt
;
10092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10096 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10098 digest
[0] -= SHA1M_A
;
10099 digest
[1] -= SHA1M_B
;
10100 digest
[2] -= SHA1M_C
;
10101 digest
[3] -= SHA1M_D
;
10102 digest
[4] -= SHA1M_E
;
10104 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10106 uint salt_len
= input_len
- 40 - 1;
10108 char *salt_buf
= input_buf
+ 40 + 1;
10110 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10112 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10114 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10116 salt
->salt_len
= salt_len
;
10118 return (PARSER_OK
);
10121 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10123 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10125 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10129 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10132 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10134 char *iter_pos
= input_buf
+ 6;
10136 salt_t
*salt
= hash_buf
->salt
;
10138 uint iter
= atoi (iter_pos
);
10142 iter
= ROUNDS_DCC2
;
10145 salt
->salt_iter
= iter
- 1;
10147 char *salt_pos
= strchr (iter_pos
, '#');
10149 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10153 char *digest_pos
= strchr (salt_pos
, '#');
10155 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10159 uint salt_len
= digest_pos
- salt_pos
- 1;
10161 u32
*digest
= (u32
*) hash_buf
->digest
;
10163 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10164 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10165 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10166 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10168 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10170 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10172 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10174 salt
->salt_len
= salt_len
;
10176 return (PARSER_OK
);
10179 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10181 u32
*digest
= (u32
*) hash_buf
->digest
;
10183 salt_t
*salt
= hash_buf
->salt
;
10185 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10189 memcpy (&in
, input_buf
, input_len
);
10191 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10193 memcpy (digest
, in
.keymic
, 16);
10196 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10197 The phrase "Pairwise key expansion"
10198 Access Point Address (referred to as Authenticator Address AA)
10199 Supplicant Address (referred to as Supplicant Address SA)
10200 Access Point Nonce (referred to as Authenticator Anonce)
10201 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10204 uint salt_len
= strlen (in
.essid
);
10208 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10210 return (PARSER_SALT_LENGTH
);
10213 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10215 salt
->salt_len
= salt_len
;
10217 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10219 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10221 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10223 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10225 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10226 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10230 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10231 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10234 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10236 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10237 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10241 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10242 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10245 for (int i
= 0; i
< 25; i
++)
10247 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10250 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10251 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10252 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10253 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10255 wpa
->keyver
= in
.keyver
;
10257 if (wpa
->keyver
> 255)
10259 log_info ("ATTENTION!");
10260 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10261 log_info (" This could be due to a recent aircrack-ng bug.");
10262 log_info (" The key version was automatically reset to a reasonable value.");
10265 wpa
->keyver
&= 0xff;
10268 wpa
->eapol_size
= in
.eapol_size
;
10270 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10272 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10274 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10276 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10278 if (wpa
->keyver
== 1)
10284 digest
[0] = byte_swap_32 (digest
[0]);
10285 digest
[1] = byte_swap_32 (digest
[1]);
10286 digest
[2] = byte_swap_32 (digest
[2]);
10287 digest
[3] = byte_swap_32 (digest
[3]);
10289 for (int i
= 0; i
< 64; i
++)
10291 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10295 uint32_t *p0
= (uint32_t *) in
.essid
;
10299 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10300 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10302 salt
->salt_buf
[10] = c0
;
10303 salt
->salt_buf
[11] = c1
;
10305 return (PARSER_OK
);
10308 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10310 u32
*digest
= (u32
*) hash_buf
->digest
;
10312 salt_t
*salt
= hash_buf
->salt
;
10314 if (input_len
== 0)
10316 log_error ("Password Safe v2 container not specified");
10321 FILE *fp
= fopen (input_buf
, "rb");
10325 log_error ("%s: %s", input_buf
, strerror (errno
));
10332 memset (&buf
, 0, sizeof (psafe2_hdr
));
10334 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10338 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10340 salt
->salt_buf
[0] = buf
.random
[0];
10341 salt
->salt_buf
[1] = buf
.random
[1];
10343 salt
->salt_len
= 8;
10344 salt
->salt_iter
= 1000;
10346 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10347 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10348 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10349 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10350 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10352 return (PARSER_OK
);
10355 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10357 u32
*digest
= (u32
*) hash_buf
->digest
;
10359 salt_t
*salt
= hash_buf
->salt
;
10361 if (input_len
== 0)
10363 log_error (".psafe3 not specified");
10368 FILE *fp
= fopen (input_buf
, "rb");
10372 log_error ("%s: %s", input_buf
, strerror (errno
));
10379 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10383 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10385 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10387 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10389 salt
->salt_iter
= in
.iterations
+ 1;
10391 salt
->salt_buf
[0] = in
.salt_buf
[0];
10392 salt
->salt_buf
[1] = in
.salt_buf
[1];
10393 salt
->salt_buf
[2] = in
.salt_buf
[2];
10394 salt
->salt_buf
[3] = in
.salt_buf
[3];
10395 salt
->salt_buf
[4] = in
.salt_buf
[4];
10396 salt
->salt_buf
[5] = in
.salt_buf
[5];
10397 salt
->salt_buf
[6] = in
.salt_buf
[6];
10398 salt
->salt_buf
[7] = in
.salt_buf
[7];
10400 salt
->salt_len
= 32;
10402 digest
[0] = in
.hash_buf
[0];
10403 digest
[1] = in
.hash_buf
[1];
10404 digest
[2] = in
.hash_buf
[2];
10405 digest
[3] = in
.hash_buf
[3];
10406 digest
[4] = in
.hash_buf
[4];
10407 digest
[5] = in
.hash_buf
[5];
10408 digest
[6] = in
.hash_buf
[6];
10409 digest
[7] = in
.hash_buf
[7];
10411 digest
[0] = byte_swap_32 (digest
[0]);
10412 digest
[1] = byte_swap_32 (digest
[1]);
10413 digest
[2] = byte_swap_32 (digest
[2]);
10414 digest
[3] = byte_swap_32 (digest
[3]);
10415 digest
[4] = byte_swap_32 (digest
[4]);
10416 digest
[5] = byte_swap_32 (digest
[5]);
10417 digest
[6] = byte_swap_32 (digest
[6]);
10418 digest
[7] = byte_swap_32 (digest
[7]);
10420 return (PARSER_OK
);
10423 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10425 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10427 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10429 u32
*digest
= (u32
*) hash_buf
->digest
;
10431 salt_t
*salt
= hash_buf
->salt
;
10433 char *iter_pos
= input_buf
+ 3;
10435 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10437 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10439 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10441 salt
->salt_iter
= salt_iter
;
10443 char *salt_pos
= iter_pos
+ 1;
10447 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10449 salt
->salt_len
= salt_len
;
10451 char *hash_pos
= salt_pos
+ salt_len
;
10453 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10455 return (PARSER_OK
);
10458 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10460 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10462 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10464 u32
*digest
= (u32
*) hash_buf
->digest
;
10466 salt_t
*salt
= hash_buf
->salt
;
10468 char *salt_pos
= input_buf
+ 3;
10470 uint iterations_len
= 0;
10472 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10476 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10478 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10479 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10483 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10487 iterations_len
+= 8;
10491 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10494 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10496 char *hash_pos
= strchr (salt_pos
, '$');
10498 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10500 uint salt_len
= hash_pos
- salt_pos
;
10502 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10504 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10506 salt
->salt_len
= salt_len
;
10510 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10512 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10514 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10516 return (PARSER_OK
);
10519 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10521 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10523 u32
*digest
= (u32
*) hash_buf
->digest
;
10525 salt_t
*salt
= hash_buf
->salt
;
10527 char *salt_pos
= input_buf
+ 6;
10529 uint iterations_len
= 0;
10531 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10535 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10537 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10538 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10542 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10546 iterations_len
+= 8;
10550 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10553 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10555 char *hash_pos
= strchr (salt_pos
, '$');
10557 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10559 uint salt_len
= hash_pos
- salt_pos
;
10561 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10563 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10565 salt
->salt_len
= salt_len
;
10569 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10571 return (PARSER_OK
);
10574 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10576 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10578 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10580 u32
*digest
= (u32
*) hash_buf
->digest
;
10582 salt_t
*salt
= hash_buf
->salt
;
10584 char *salt_pos
= input_buf
+ 14;
10586 char *hash_pos
= strchr (salt_pos
, '*');
10588 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10592 uint salt_len
= hash_pos
- salt_pos
- 1;
10594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10596 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10600 salt
->salt_len
= salt_len
;
10602 u8 tmp_buf
[100] = { 0 };
10604 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10606 memcpy (digest
, tmp_buf
, 20);
10608 digest
[0] = byte_swap_32 (digest
[0]);
10609 digest
[1] = byte_swap_32 (digest
[1]);
10610 digest
[2] = byte_swap_32 (digest
[2]);
10611 digest
[3] = byte_swap_32 (digest
[3]);
10612 digest
[4] = byte_swap_32 (digest
[4]);
10614 digest
[0] -= SHA1M_A
;
10615 digest
[1] -= SHA1M_B
;
10616 digest
[2] -= SHA1M_C
;
10617 digest
[3] -= SHA1M_D
;
10618 digest
[4] -= SHA1M_E
;
10620 return (PARSER_OK
);
10623 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10625 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10627 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10629 if (c12
& 3) return (PARSER_HASH_VALUE
);
10631 u32
*digest
= (u32
*) hash_buf
->digest
;
10633 salt_t
*salt
= hash_buf
->salt
;
10635 // for ascii_digest
10636 salt
->salt_sign
[0] = input_buf
[0];
10637 salt
->salt_sign
[1] = input_buf
[1];
10639 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10640 | itoa64_to_int (input_buf
[1]) << 6;
10642 salt
->salt_len
= 2;
10644 u8 tmp_buf
[100] = { 0 };
10646 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10648 memcpy (digest
, tmp_buf
, 8);
10652 IP (digest
[0], digest
[1], tt
);
10657 return (PARSER_OK
);
10660 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10662 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10664 u32
*digest
= (u32
*) hash_buf
->digest
;
10666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10671 digest
[0] = byte_swap_32 (digest
[0]);
10672 digest
[1] = byte_swap_32 (digest
[1]);
10673 digest
[2] = byte_swap_32 (digest
[2]);
10674 digest
[3] = byte_swap_32 (digest
[3]);
10676 digest
[0] -= MD4M_A
;
10677 digest
[1] -= MD4M_B
;
10678 digest
[2] -= MD4M_C
;
10679 digest
[3] -= MD4M_D
;
10681 return (PARSER_OK
);
10684 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10686 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10688 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10692 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10695 u32
*digest
= (u32
*) hash_buf
->digest
;
10697 salt_t
*salt
= hash_buf
->salt
;
10699 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10700 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10701 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10702 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10704 digest
[0] = byte_swap_32 (digest
[0]);
10705 digest
[1] = byte_swap_32 (digest
[1]);
10706 digest
[2] = byte_swap_32 (digest
[2]);
10707 digest
[3] = byte_swap_32 (digest
[3]);
10709 digest
[0] -= MD4M_A
;
10710 digest
[1] -= MD4M_B
;
10711 digest
[2] -= MD4M_C
;
10712 digest
[3] -= MD4M_D
;
10714 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10716 uint salt_len
= input_len
- 32 - 1;
10718 char *salt_buf
= input_buf
+ 32 + 1;
10720 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10722 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10724 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10726 salt
->salt_len
= salt_len
;
10728 return (PARSER_OK
);
10731 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10733 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10735 u32
*digest
= (u32
*) hash_buf
->digest
;
10737 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10738 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10739 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10740 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10742 digest
[0] = byte_swap_32 (digest
[0]);
10743 digest
[1] = byte_swap_32 (digest
[1]);
10744 digest
[2] = byte_swap_32 (digest
[2]);
10745 digest
[3] = byte_swap_32 (digest
[3]);
10747 digest
[0] -= MD5M_A
;
10748 digest
[1] -= MD5M_B
;
10749 digest
[2] -= MD5M_C
;
10750 digest
[3] -= MD5M_D
;
10752 return (PARSER_OK
);
10755 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10757 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10759 u32
*digest
= (u32
*) hash_buf
->digest
;
10761 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10762 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10766 digest
[0] = byte_swap_32 (digest
[0]);
10767 digest
[1] = byte_swap_32 (digest
[1]);
10769 return (PARSER_OK
);
10772 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10774 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10776 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10780 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10783 u32
*digest
= (u32
*) hash_buf
->digest
;
10785 salt_t
*salt
= hash_buf
->salt
;
10787 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10788 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10789 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10790 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10792 digest
[0] = byte_swap_32 (digest
[0]);
10793 digest
[1] = byte_swap_32 (digest
[1]);
10794 digest
[2] = byte_swap_32 (digest
[2]);
10795 digest
[3] = byte_swap_32 (digest
[3]);
10797 digest
[0] -= MD5M_A
;
10798 digest
[1] -= MD5M_B
;
10799 digest
[2] -= MD5M_C
;
10800 digest
[3] -= MD5M_D
;
10802 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10804 uint salt_len
= input_len
- 32 - 1;
10806 char *salt_buf
= input_buf
+ 32 + 1;
10808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10810 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10812 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10814 salt
->salt_len
= salt_len
;
10816 return (PARSER_OK
);
10819 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10821 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10823 u32
*digest
= (u32
*) hash_buf
->digest
;
10825 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10826 | itoa64_to_int (input_buf
[ 1]) << 6
10827 | itoa64_to_int (input_buf
[ 2]) << 12
10828 | itoa64_to_int (input_buf
[ 3]) << 18;
10829 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10830 | itoa64_to_int (input_buf
[ 5]) << 6
10831 | itoa64_to_int (input_buf
[ 6]) << 12
10832 | itoa64_to_int (input_buf
[ 7]) << 18;
10833 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10834 | itoa64_to_int (input_buf
[ 9]) << 6
10835 | itoa64_to_int (input_buf
[10]) << 12
10836 | itoa64_to_int (input_buf
[11]) << 18;
10837 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10838 | itoa64_to_int (input_buf
[13]) << 6
10839 | itoa64_to_int (input_buf
[14]) << 12
10840 | itoa64_to_int (input_buf
[15]) << 18;
10842 digest
[0] -= MD5M_A
;
10843 digest
[1] -= MD5M_B
;
10844 digest
[2] -= MD5M_C
;
10845 digest
[3] -= MD5M_D
;
10847 digest
[0] &= 0x00ffffff;
10848 digest
[1] &= 0x00ffffff;
10849 digest
[2] &= 0x00ffffff;
10850 digest
[3] &= 0x00ffffff;
10852 return (PARSER_OK
);
10855 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10857 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10859 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10863 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10866 u32
*digest
= (u32
*) hash_buf
->digest
;
10868 salt_t
*salt
= hash_buf
->salt
;
10870 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10871 | itoa64_to_int (input_buf
[ 1]) << 6
10872 | itoa64_to_int (input_buf
[ 2]) << 12
10873 | itoa64_to_int (input_buf
[ 3]) << 18;
10874 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10875 | itoa64_to_int (input_buf
[ 5]) << 6
10876 | itoa64_to_int (input_buf
[ 6]) << 12
10877 | itoa64_to_int (input_buf
[ 7]) << 18;
10878 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10879 | itoa64_to_int (input_buf
[ 9]) << 6
10880 | itoa64_to_int (input_buf
[10]) << 12
10881 | itoa64_to_int (input_buf
[11]) << 18;
10882 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10883 | itoa64_to_int (input_buf
[13]) << 6
10884 | itoa64_to_int (input_buf
[14]) << 12
10885 | itoa64_to_int (input_buf
[15]) << 18;
10887 digest
[0] -= MD5M_A
;
10888 digest
[1] -= MD5M_B
;
10889 digest
[2] -= MD5M_C
;
10890 digest
[3] -= MD5M_D
;
10892 digest
[0] &= 0x00ffffff;
10893 digest
[1] &= 0x00ffffff;
10894 digest
[2] &= 0x00ffffff;
10895 digest
[3] &= 0x00ffffff;
10897 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10899 uint salt_len
= input_len
- 16 - 1;
10901 char *salt_buf
= input_buf
+ 16 + 1;
10903 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10905 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10907 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10909 salt
->salt_len
= salt_len
;
10911 return (PARSER_OK
);
10914 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10916 key
[0] = (nthash
[0] >> 0);
10917 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10918 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10919 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10920 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10921 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10922 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10923 key
[7] = (nthash
[6] << 1);
10935 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10937 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10939 u32
*digest
= (u32
*) hash_buf
->digest
;
10941 salt_t
*salt
= hash_buf
->salt
;
10943 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10949 char *user_pos
= input_buf
;
10951 char *unused_pos
= strchr (user_pos
, ':');
10953 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10955 uint user_len
= unused_pos
- user_pos
;
10957 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10961 char *domain_pos
= strchr (unused_pos
, ':');
10963 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10965 uint unused_len
= domain_pos
- unused_pos
;
10967 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10971 char *srvchall_pos
= strchr (domain_pos
, ':');
10973 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10975 uint domain_len
= srvchall_pos
- domain_pos
;
10977 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10981 char *hash_pos
= strchr (srvchall_pos
, ':');
10983 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10985 uint srvchall_len
= hash_pos
- srvchall_pos
;
10987 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10991 char *clichall_pos
= strchr (hash_pos
, ':');
10993 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10995 uint hash_len
= clichall_pos
- hash_pos
;
10997 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11001 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11003 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11006 * store some data for later use
11009 netntlm
->user_len
= user_len
* 2;
11010 netntlm
->domain_len
= domain_len
* 2;
11011 netntlm
->srvchall_len
= srvchall_len
/ 2;
11012 netntlm
->clichall_len
= clichall_len
/ 2;
11014 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11015 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11018 * handle username and domainname
11021 for (uint i
= 0; i
< user_len
; i
++)
11023 *userdomain_ptr
++ = user_pos
[i
];
11024 *userdomain_ptr
++ = 0;
11027 for (uint i
= 0; i
< domain_len
; i
++)
11029 *userdomain_ptr
++ = domain_pos
[i
];
11030 *userdomain_ptr
++ = 0;
11034 * handle server challenge encoding
11037 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11039 const char p0
= srvchall_pos
[i
+ 0];
11040 const char p1
= srvchall_pos
[i
+ 1];
11042 *chall_ptr
++ = hex_convert (p1
) << 0
11043 | hex_convert (p0
) << 4;
11047 * handle client challenge encoding
11050 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11052 const char p0
= clichall_pos
[i
+ 0];
11053 const char p1
= clichall_pos
[i
+ 1];
11055 *chall_ptr
++ = hex_convert (p1
) << 0
11056 | hex_convert (p0
) << 4;
11063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11065 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11067 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11069 salt
->salt_len
= salt_len
;
11071 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11072 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11073 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11074 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11076 digest
[0] = byte_swap_32 (digest
[0]);
11077 digest
[1] = byte_swap_32 (digest
[1]);
11078 digest
[2] = byte_swap_32 (digest
[2]);
11079 digest
[3] = byte_swap_32 (digest
[3]);
11081 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11083 uint digest_tmp
[2] = { 0 };
11085 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11086 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11088 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11089 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11091 /* special case 2: ESS */
11093 if (srvchall_len
== 48)
11095 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11097 uint w
[16] = { 0 };
11099 w
[ 0] = netntlm
->chall_buf
[6];
11100 w
[ 1] = netntlm
->chall_buf
[7];
11101 w
[ 2] = netntlm
->chall_buf
[0];
11102 w
[ 3] = netntlm
->chall_buf
[1];
11106 uint dgst
[4] = { 0 };
11115 salt
->salt_buf
[0] = dgst
[0];
11116 salt
->salt_buf
[1] = dgst
[1];
11120 /* precompute netntlmv1 exploit start */
11122 for (uint i
= 0; i
< 0x10000; i
++)
11124 uint key_md4
[2] = { i
, 0 };
11125 uint key_des
[2] = { 0, 0 };
11127 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11129 uint Kc
[16] = { 0 };
11130 uint Kd
[16] = { 0 };
11132 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11134 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11136 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11138 if (data3
[0] != digest_tmp
[0]) continue;
11139 if (data3
[1] != digest_tmp
[1]) continue;
11141 salt
->salt_buf
[2] = i
;
11143 salt
->salt_len
= 24;
11148 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11149 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11151 /* precompute netntlmv1 exploit stop */
11155 IP (digest
[0], digest
[1], tt
);
11156 IP (digest
[2], digest
[3], tt
);
11158 digest
[0] = rotr32 (digest
[0], 29);
11159 digest
[1] = rotr32 (digest
[1], 29);
11160 digest
[2] = rotr32 (digest
[2], 29);
11161 digest
[3] = rotr32 (digest
[3], 29);
11163 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11165 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11166 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11168 return (PARSER_OK
);
11171 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11173 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11175 u32
*digest
= (u32
*) hash_buf
->digest
;
11177 salt_t
*salt
= hash_buf
->salt
;
11179 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11185 char *user_pos
= input_buf
;
11187 char *unused_pos
= strchr (user_pos
, ':');
11189 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11191 uint user_len
= unused_pos
- user_pos
;
11193 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11197 char *domain_pos
= strchr (unused_pos
, ':');
11199 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11201 uint unused_len
= domain_pos
- unused_pos
;
11203 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11207 char *srvchall_pos
= strchr (domain_pos
, ':');
11209 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11211 uint domain_len
= srvchall_pos
- domain_pos
;
11213 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11217 char *hash_pos
= strchr (srvchall_pos
, ':');
11219 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11221 uint srvchall_len
= hash_pos
- srvchall_pos
;
11223 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11227 char *clichall_pos
= strchr (hash_pos
, ':');
11229 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11231 uint hash_len
= clichall_pos
- hash_pos
;
11233 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11237 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11239 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11241 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11244 * store some data for later use
11247 netntlm
->user_len
= user_len
* 2;
11248 netntlm
->domain_len
= domain_len
* 2;
11249 netntlm
->srvchall_len
= srvchall_len
/ 2;
11250 netntlm
->clichall_len
= clichall_len
/ 2;
11252 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11253 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11256 * handle username and domainname
11259 for (uint i
= 0; i
< user_len
; i
++)
11261 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11262 *userdomain_ptr
++ = 0;
11265 for (uint i
= 0; i
< domain_len
; i
++)
11267 *userdomain_ptr
++ = domain_pos
[i
];
11268 *userdomain_ptr
++ = 0;
11271 *userdomain_ptr
++ = 0x80;
11274 * handle server challenge encoding
11277 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11279 const char p0
= srvchall_pos
[i
+ 0];
11280 const char p1
= srvchall_pos
[i
+ 1];
11282 *chall_ptr
++ = hex_convert (p1
) << 0
11283 | hex_convert (p0
) << 4;
11287 * handle client challenge encoding
11290 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11292 const char p0
= clichall_pos
[i
+ 0];
11293 const char p1
= clichall_pos
[i
+ 1];
11295 *chall_ptr
++ = hex_convert (p1
) << 0
11296 | hex_convert (p0
) << 4;
11299 *chall_ptr
++ = 0x80;
11302 * handle hash itself
11305 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11306 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11307 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11308 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11310 digest
[0] = byte_swap_32 (digest
[0]);
11311 digest
[1] = byte_swap_32 (digest
[1]);
11312 digest
[2] = byte_swap_32 (digest
[2]);
11313 digest
[3] = byte_swap_32 (digest
[3]);
11316 * reuse challange data as salt_buf, its the buffer that is most likely unique
11319 salt
->salt_buf
[0] = 0;
11320 salt
->salt_buf
[1] = 0;
11321 salt
->salt_buf
[2] = 0;
11322 salt
->salt_buf
[3] = 0;
11323 salt
->salt_buf
[4] = 0;
11324 salt
->salt_buf
[5] = 0;
11325 salt
->salt_buf
[6] = 0;
11326 salt
->salt_buf
[7] = 0;
11330 uptr
= (uint
*) netntlm
->userdomain_buf
;
11332 for (uint i
= 0; i
< 16; i
+= 16)
11334 md5_64 (uptr
, salt
->salt_buf
);
11337 uptr
= (uint
*) netntlm
->chall_buf
;
11339 for (uint i
= 0; i
< 256; i
+= 16)
11341 md5_64 (uptr
, salt
->salt_buf
);
11344 salt
->salt_len
= 16;
11346 return (PARSER_OK
);
11349 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11351 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11353 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11357 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11360 u32
*digest
= (u32
*) hash_buf
->digest
;
11362 salt_t
*salt
= hash_buf
->salt
;
11364 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11365 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11366 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11367 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11369 digest
[0] = byte_swap_32 (digest
[0]);
11370 digest
[1] = byte_swap_32 (digest
[1]);
11371 digest
[2] = byte_swap_32 (digest
[2]);
11372 digest
[3] = byte_swap_32 (digest
[3]);
11374 digest
[0] -= MD5M_A
;
11375 digest
[1] -= MD5M_B
;
11376 digest
[2] -= MD5M_C
;
11377 digest
[3] -= MD5M_D
;
11379 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11381 uint salt_len
= input_len
- 32 - 1;
11383 char *salt_buf
= input_buf
+ 32 + 1;
11385 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11387 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11391 salt
->salt_len
= salt_len
;
11393 return (PARSER_OK
);
11396 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11398 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11400 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11404 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11407 u32
*digest
= (u32
*) hash_buf
->digest
;
11409 salt_t
*salt
= hash_buf
->salt
;
11411 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11412 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11413 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11414 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11416 digest
[0] = byte_swap_32 (digest
[0]);
11417 digest
[1] = byte_swap_32 (digest
[1]);
11418 digest
[2] = byte_swap_32 (digest
[2]);
11419 digest
[3] = byte_swap_32 (digest
[3]);
11421 digest
[0] -= MD5M_A
;
11422 digest
[1] -= MD5M_B
;
11423 digest
[2] -= MD5M_C
;
11424 digest
[3] -= MD5M_D
;
11426 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11428 uint salt_len
= input_len
- 32 - 1;
11430 char *salt_buf
= input_buf
+ 32 + 1;
11432 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11434 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11436 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11438 salt
->salt_len
= salt_len
;
11440 return (PARSER_OK
);
11443 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11445 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11447 u32
*digest
= (u32
*) hash_buf
->digest
;
11449 salt_t
*salt
= hash_buf
->salt
;
11451 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11452 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11453 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11454 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11456 digest
[0] = byte_swap_32 (digest
[0]);
11457 digest
[1] = byte_swap_32 (digest
[1]);
11458 digest
[2] = byte_swap_32 (digest
[2]);
11459 digest
[3] = byte_swap_32 (digest
[3]);
11461 digest
[0] -= MD5M_A
;
11462 digest
[1] -= MD5M_B
;
11463 digest
[2] -= MD5M_C
;
11464 digest
[3] -= MD5M_D
;
11467 * This is a virtual salt. While the algorithm is basically not salted
11468 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11469 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11472 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11474 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11476 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11478 salt
->salt_len
= salt_len
;
11480 return (PARSER_OK
);
11483 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11485 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11487 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11491 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11494 u32
*digest
= (u32
*) hash_buf
->digest
;
11496 salt_t
*salt
= hash_buf
->salt
;
11498 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11499 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11500 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11501 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11503 digest
[0] = byte_swap_32 (digest
[0]);
11504 digest
[1] = byte_swap_32 (digest
[1]);
11505 digest
[2] = byte_swap_32 (digest
[2]);
11506 digest
[3] = byte_swap_32 (digest
[3]);
11508 digest
[0] -= MD5M_A
;
11509 digest
[1] -= MD5M_B
;
11510 digest
[2] -= MD5M_C
;
11511 digest
[3] -= MD5M_D
;
11513 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11515 uint salt_len
= input_len
- 32 - 1;
11517 char *salt_buf
= input_buf
+ 32 + 1;
11519 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11521 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11523 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11525 salt
->salt_len
= salt_len
;
11527 return (PARSER_OK
);
11530 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11532 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11534 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11538 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11541 u32
*digest
= (u32
*) hash_buf
->digest
;
11543 salt_t
*salt
= hash_buf
->salt
;
11545 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11546 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11547 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11548 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11550 digest
[0] = byte_swap_32 (digest
[0]);
11551 digest
[1] = byte_swap_32 (digest
[1]);
11552 digest
[2] = byte_swap_32 (digest
[2]);
11553 digest
[3] = byte_swap_32 (digest
[3]);
11555 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11557 uint salt_len
= input_len
- 32 - 1;
11559 char *salt_buf
= input_buf
+ 32 + 1;
11561 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11563 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11565 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11567 salt
->salt_len
= salt_len
;
11569 return (PARSER_OK
);
11572 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11574 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11576 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11580 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11583 u32
*digest
= (u32
*) hash_buf
->digest
;
11585 salt_t
*salt
= hash_buf
->salt
;
11587 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11588 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11589 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11590 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11592 digest
[0] = byte_swap_32 (digest
[0]);
11593 digest
[1] = byte_swap_32 (digest
[1]);
11594 digest
[2] = byte_swap_32 (digest
[2]);
11595 digest
[3] = byte_swap_32 (digest
[3]);
11597 digest
[0] -= MD4M_A
;
11598 digest
[1] -= MD4M_B
;
11599 digest
[2] -= MD4M_C
;
11600 digest
[3] -= MD4M_D
;
11602 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11604 uint salt_len
= input_len
- 32 - 1;
11606 char *salt_buf
= input_buf
+ 32 + 1;
11608 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11610 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11612 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11614 salt
->salt_len
= salt_len
;
11616 return (PARSER_OK
);
11619 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11621 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11623 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11627 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11630 u32
*digest
= (u32
*) hash_buf
->digest
;
11632 salt_t
*salt
= hash_buf
->salt
;
11634 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11635 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11636 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11637 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11639 digest
[0] = byte_swap_32 (digest
[0]);
11640 digest
[1] = byte_swap_32 (digest
[1]);
11641 digest
[2] = byte_swap_32 (digest
[2]);
11642 digest
[3] = byte_swap_32 (digest
[3]);
11644 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11646 uint salt_len
= input_len
- 32 - 1;
11648 char *salt_buf
= input_buf
+ 32 + 1;
11650 uint salt_pc_block
[16] = { 0 };
11652 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11654 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11656 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11658 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11660 salt_pc_block
[14] = salt_len
* 8;
11662 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11664 md5_64 (salt_pc_block
, salt_pc_digest
);
11666 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11667 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11668 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11669 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11671 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11673 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11675 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11677 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11678 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11679 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11680 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11682 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11684 return (PARSER_OK
);
11687 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11689 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11691 u32
*digest
= (u32
*) hash_buf
->digest
;
11693 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11694 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11695 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11696 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11697 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11699 digest
[0] -= SHA1M_A
;
11700 digest
[1] -= SHA1M_B
;
11701 digest
[2] -= SHA1M_C
;
11702 digest
[3] -= SHA1M_D
;
11703 digest
[4] -= SHA1M_E
;
11705 return (PARSER_OK
);
11708 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11710 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11712 u32
*digest
= (u32
*) hash_buf
->digest
;
11714 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11715 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11716 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11717 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11718 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11720 return (PARSER_OK
);
11723 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11725 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11727 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11729 u32
*digest
= (u32
*) hash_buf
->digest
;
11733 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11734 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11735 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11736 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11737 digest
[4] = 0x00000000;
11739 return (PARSER_OK
);
11742 int sha1s_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_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11750 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) 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]);
11761 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11763 digest
[0] -= SHA1M_A
;
11764 digest
[1] -= SHA1M_B
;
11765 digest
[2] -= SHA1M_C
;
11766 digest
[3] -= SHA1M_D
;
11767 digest
[4] -= SHA1M_E
;
11769 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11771 uint salt_len
= input_len
- 40 - 1;
11773 char *salt_buf
= input_buf
+ 40 + 1;
11775 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11777 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11779 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11781 salt
->salt_len
= salt_len
;
11783 return (PARSER_OK
);
11786 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11788 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11790 u32
*digest
= (u32
*) hash_buf
->digest
;
11792 salt_t
*salt
= hash_buf
->salt
;
11794 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11796 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11797 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11798 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11799 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11800 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11802 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11804 uint salt_len
= input_len
- 40 - 1;
11806 char *salt_buf
= input_buf
+ 40 + 1;
11808 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11810 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
11812 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
11814 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
11817 pstoken
->salt_len
= salt_len
/ 2;
11819 /* some fake salt for the sorting mechanisms */
11821 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
11822 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
11823 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
11824 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
11825 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
11826 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
11827 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
11828 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
11830 salt
->salt_len
= 32;
11832 /* we need to check if we can precompute some of the data --
11833 this is possible since the scheme is badly designed */
11835 pstoken
->pc_digest
[0] = SHA1M_A
;
11836 pstoken
->pc_digest
[1] = SHA1M_B
;
11837 pstoken
->pc_digest
[2] = SHA1M_C
;
11838 pstoken
->pc_digest
[3] = SHA1M_D
;
11839 pstoken
->pc_digest
[4] = SHA1M_E
;
11841 pstoken
->pc_offset
= 0;
11843 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
11847 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
11848 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
11849 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
11850 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
11851 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
11852 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
11853 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
11854 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
11855 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
11856 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
11857 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
11858 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
11859 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
11860 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
11861 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
11862 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
11864 sha1_64 (w
, pstoken
->pc_digest
);
11866 pstoken
->pc_offset
+= 16;
11869 return (PARSER_OK
);
11872 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11874 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11876 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11878 u32
*digest
= (u32
*) hash_buf
->digest
;
11880 u8 tmp_buf
[100] = { 0 };
11882 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11884 memcpy (digest
, tmp_buf
, 20);
11886 digest
[0] = byte_swap_32 (digest
[0]);
11887 digest
[1] = byte_swap_32 (digest
[1]);
11888 digest
[2] = byte_swap_32 (digest
[2]);
11889 digest
[3] = byte_swap_32 (digest
[3]);
11890 digest
[4] = byte_swap_32 (digest
[4]);
11892 digest
[0] -= SHA1M_A
;
11893 digest
[1] -= SHA1M_B
;
11894 digest
[2] -= SHA1M_C
;
11895 digest
[3] -= SHA1M_D
;
11896 digest
[4] -= SHA1M_E
;
11898 return (PARSER_OK
);
11901 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11903 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11905 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11907 u32
*digest
= (u32
*) hash_buf
->digest
;
11909 salt_t
*salt
= hash_buf
->salt
;
11911 u8 tmp_buf
[100] = { 0 };
11913 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11915 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11917 memcpy (digest
, tmp_buf
, 20);
11919 int salt_len
= tmp_len
- 20;
11921 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11923 salt
->salt_len
= salt_len
;
11925 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11927 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11929 char *ptr
= (char *) salt
->salt_buf
;
11931 ptr
[salt
->salt_len
] = 0x80;
11934 digest
[0] = byte_swap_32 (digest
[0]);
11935 digest
[1] = byte_swap_32 (digest
[1]);
11936 digest
[2] = byte_swap_32 (digest
[2]);
11937 digest
[3] = byte_swap_32 (digest
[3]);
11938 digest
[4] = byte_swap_32 (digest
[4]);
11940 digest
[0] -= SHA1M_A
;
11941 digest
[1] -= SHA1M_B
;
11942 digest
[2] -= SHA1M_C
;
11943 digest
[3] -= SHA1M_D
;
11944 digest
[4] -= SHA1M_E
;
11946 return (PARSER_OK
);
11949 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11951 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11953 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11955 u32
*digest
= (u32
*) hash_buf
->digest
;
11957 salt_t
*salt
= hash_buf
->salt
;
11959 char *salt_buf
= input_buf
+ 6;
11963 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11965 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11967 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11969 salt
->salt_len
= salt_len
;
11971 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11973 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11974 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11975 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11976 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11977 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11979 digest
[0] -= SHA1M_A
;
11980 digest
[1] -= SHA1M_B
;
11981 digest
[2] -= SHA1M_C
;
11982 digest
[3] -= SHA1M_D
;
11983 digest
[4] -= SHA1M_E
;
11985 return (PARSER_OK
);
11988 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11990 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11992 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11994 u32
*digest
= (u32
*) hash_buf
->digest
;
11996 salt_t
*salt
= hash_buf
->salt
;
11998 char *salt_buf
= input_buf
+ 6;
12002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12004 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12006 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12008 salt
->salt_len
= salt_len
;
12010 char *hash_pos
= input_buf
+ 6 + 8;
12012 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12013 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12014 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12015 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12016 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12018 digest
[0] -= SHA1M_A
;
12019 digest
[1] -= SHA1M_B
;
12020 digest
[2] -= SHA1M_C
;
12021 digest
[3] -= SHA1M_D
;
12022 digest
[4] -= SHA1M_E
;
12024 return (PARSER_OK
);
12027 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12029 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12031 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12033 u64
*digest
= (u64
*) hash_buf
->digest
;
12035 salt_t
*salt
= hash_buf
->salt
;
12037 char *salt_buf
= input_buf
+ 6;
12041 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12043 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12045 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12047 salt
->salt_len
= salt_len
;
12049 char *hash_pos
= input_buf
+ 6 + 8;
12051 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12052 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12053 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12054 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12055 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12056 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12057 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12058 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12060 digest
[0] -= SHA512M_A
;
12061 digest
[1] -= SHA512M_B
;
12062 digest
[2] -= SHA512M_C
;
12063 digest
[3] -= SHA512M_D
;
12064 digest
[4] -= SHA512M_E
;
12065 digest
[5] -= SHA512M_F
;
12066 digest
[6] -= SHA512M_G
;
12067 digest
[7] -= SHA512M_H
;
12069 return (PARSER_OK
);
12072 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12074 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12076 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12080 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12083 u32
*digest
= (u32
*) hash_buf
->digest
;
12085 salt_t
*salt
= hash_buf
->salt
;
12087 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12088 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12092 digest
[0] = byte_swap_32 (digest
[0]);
12093 digest
[1] = byte_swap_32 (digest
[1]);
12095 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12097 uint salt_len
= input_len
- 16 - 1;
12099 char *salt_buf
= input_buf
+ 16 + 1;
12101 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12103 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12105 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12107 salt
->salt_len
= salt_len
;
12109 return (PARSER_OK
);
12112 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12114 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12116 u32
*digest
= (u32
*) hash_buf
->digest
;
12118 salt_t
*salt
= hash_buf
->salt
;
12120 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12121 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12122 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12123 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12124 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12126 digest
[0] -= SHA1M_A
;
12127 digest
[1] -= SHA1M_B
;
12128 digest
[2] -= SHA1M_C
;
12129 digest
[3] -= SHA1M_D
;
12130 digest
[4] -= SHA1M_E
;
12132 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12134 uint salt_len
= input_len
- 40 - 1;
12136 char *salt_buf
= input_buf
+ 40 + 1;
12138 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12140 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12142 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12144 salt
->salt_len
= salt_len
;
12146 return (PARSER_OK
);
12149 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12151 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12153 u32
*digest
= (u32
*) hash_buf
->digest
;
12155 salt_t
*salt
= hash_buf
->salt
;
12157 char *hash_pos
= input_buf
;
12159 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12160 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12161 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12162 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12163 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12164 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12165 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12166 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12167 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12168 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12169 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12170 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12171 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12172 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12173 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12174 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12176 char *salt_pos
= input_buf
+ 128;
12178 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12179 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12180 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12181 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12183 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12184 salt
->salt_len
= 16;
12186 return (PARSER_OK
);
12189 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12191 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12193 u32
*digest
= (u32
*) hash_buf
->digest
;
12195 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12196 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12197 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12198 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12199 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12200 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12201 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12202 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12204 digest
[0] -= SHA256M_A
;
12205 digest
[1] -= SHA256M_B
;
12206 digest
[2] -= SHA256M_C
;
12207 digest
[3] -= SHA256M_D
;
12208 digest
[4] -= SHA256M_E
;
12209 digest
[5] -= SHA256M_F
;
12210 digest
[6] -= SHA256M_G
;
12211 digest
[7] -= SHA256M_H
;
12213 return (PARSER_OK
);
12216 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12218 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12220 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12224 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12227 u32
*digest
= (u32
*) hash_buf
->digest
;
12229 salt_t
*salt
= hash_buf
->salt
;
12231 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12232 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12233 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12234 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12235 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12236 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12237 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12238 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12240 digest
[0] -= SHA256M_A
;
12241 digest
[1] -= SHA256M_B
;
12242 digest
[2] -= SHA256M_C
;
12243 digest
[3] -= SHA256M_D
;
12244 digest
[4] -= SHA256M_E
;
12245 digest
[5] -= SHA256M_F
;
12246 digest
[6] -= SHA256M_G
;
12247 digest
[7] -= SHA256M_H
;
12249 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12251 uint salt_len
= input_len
- 64 - 1;
12253 char *salt_buf
= input_buf
+ 64 + 1;
12255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12257 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12261 salt
->salt_len
= salt_len
;
12263 return (PARSER_OK
);
12266 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12268 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12270 u64
*digest
= (u64
*) hash_buf
->digest
;
12272 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12273 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12274 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12275 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12276 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12277 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12281 digest
[0] -= SHA384M_A
;
12282 digest
[1] -= SHA384M_B
;
12283 digest
[2] -= SHA384M_C
;
12284 digest
[3] -= SHA384M_D
;
12285 digest
[4] -= SHA384M_E
;
12286 digest
[5] -= SHA384M_F
;
12290 return (PARSER_OK
);
12293 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12295 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12297 u64
*digest
= (u64
*) hash_buf
->digest
;
12299 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12300 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12301 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12302 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12303 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12304 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12305 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12306 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12308 digest
[0] -= SHA512M_A
;
12309 digest
[1] -= SHA512M_B
;
12310 digest
[2] -= SHA512M_C
;
12311 digest
[3] -= SHA512M_D
;
12312 digest
[4] -= SHA512M_E
;
12313 digest
[5] -= SHA512M_F
;
12314 digest
[6] -= SHA512M_G
;
12315 digest
[7] -= SHA512M_H
;
12317 return (PARSER_OK
);
12320 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12322 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12324 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12328 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12331 u64
*digest
= (u64
*) hash_buf
->digest
;
12333 salt_t
*salt
= hash_buf
->salt
;
12335 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12336 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12337 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12338 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12339 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12340 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12341 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12342 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12344 digest
[0] -= SHA512M_A
;
12345 digest
[1] -= SHA512M_B
;
12346 digest
[2] -= SHA512M_C
;
12347 digest
[3] -= SHA512M_D
;
12348 digest
[4] -= SHA512M_E
;
12349 digest
[5] -= SHA512M_F
;
12350 digest
[6] -= SHA512M_G
;
12351 digest
[7] -= SHA512M_H
;
12353 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12355 uint salt_len
= input_len
- 128 - 1;
12357 char *salt_buf
= input_buf
+ 128 + 1;
12359 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12361 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12363 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12365 salt
->salt_len
= salt_len
;
12367 return (PARSER_OK
);
12370 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12372 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12374 u64
*digest
= (u64
*) hash_buf
->digest
;
12376 salt_t
*salt
= hash_buf
->salt
;
12378 char *salt_pos
= input_buf
+ 3;
12380 uint iterations_len
= 0;
12382 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12386 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12388 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12389 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12393 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12397 iterations_len
+= 8;
12401 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12404 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12406 char *hash_pos
= strchr (salt_pos
, '$');
12408 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12410 uint salt_len
= hash_pos
- salt_pos
;
12412 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12414 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12416 salt
->salt_len
= salt_len
;
12420 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12422 return (PARSER_OK
);
12425 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12427 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12429 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12431 u64
*digest
= (u64
*) hash_buf
->digest
;
12433 salt_t
*salt
= hash_buf
->salt
;
12435 uint keccak_mdlen
= input_len
/ 2;
12437 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12439 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12441 digest
[i
] = byte_swap_64 (digest
[i
]);
12444 salt
->keccak_mdlen
= keccak_mdlen
;
12446 return (PARSER_OK
);
12449 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12451 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12453 u32
*digest
= (u32
*) hash_buf
->digest
;
12455 salt_t
*salt
= hash_buf
->salt
;
12457 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12460 * Parse that strange long line
12465 size_t in_len
[9] = { 0 };
12467 in_off
[0] = strtok (input_buf
, ":");
12469 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12471 in_len
[0] = strlen (in_off
[0]);
12475 for (i
= 1; i
< 9; i
++)
12477 in_off
[i
] = strtok (NULL
, ":");
12479 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12481 in_len
[i
] = strlen (in_off
[i
]);
12484 char *ptr
= (char *) ikepsk
->msg_buf
;
12486 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12487 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12488 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12489 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12490 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12491 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12495 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12497 ptr
= (char *) ikepsk
->nr_buf
;
12499 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12500 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12504 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12507 * Store to database
12512 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12513 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12514 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12515 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12517 digest
[0] = byte_swap_32 (digest
[0]);
12518 digest
[1] = byte_swap_32 (digest
[1]);
12519 digest
[2] = byte_swap_32 (digest
[2]);
12520 digest
[3] = byte_swap_32 (digest
[3]);
12522 salt
->salt_len
= 32;
12524 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12525 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12526 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12527 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12528 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12529 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12530 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12531 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12533 return (PARSER_OK
);
12536 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12538 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12540 u32
*digest
= (u32
*) hash_buf
->digest
;
12542 salt_t
*salt
= hash_buf
->salt
;
12544 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12547 * Parse that strange long line
12552 size_t in_len
[9] = { 0 };
12554 in_off
[0] = strtok (input_buf
, ":");
12556 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12558 in_len
[0] = strlen (in_off
[0]);
12562 for (i
= 1; i
< 9; i
++)
12564 in_off
[i
] = strtok (NULL
, ":");
12566 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12568 in_len
[i
] = strlen (in_off
[i
]);
12571 char *ptr
= (char *) ikepsk
->msg_buf
;
12573 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12574 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12575 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12576 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12577 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12578 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12582 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12584 ptr
= (char *) ikepsk
->nr_buf
;
12586 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12587 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12591 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12594 * Store to database
12599 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12600 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12601 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12602 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12603 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12605 salt
->salt_len
= 32;
12607 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12608 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12609 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12610 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12611 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12612 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12613 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12614 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12616 return (PARSER_OK
);
12619 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12621 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12623 u32
*digest
= (u32
*) hash_buf
->digest
;
12625 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12626 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12627 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12628 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12629 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12631 digest
[0] = byte_swap_32 (digest
[0]);
12632 digest
[1] = byte_swap_32 (digest
[1]);
12633 digest
[2] = byte_swap_32 (digest
[2]);
12634 digest
[3] = byte_swap_32 (digest
[3]);
12635 digest
[4] = byte_swap_32 (digest
[4]);
12637 return (PARSER_OK
);
12640 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12642 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12644 u32
*digest
= (u32
*) hash_buf
->digest
;
12646 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12647 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12648 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12649 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12650 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12651 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12652 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12653 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12654 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12655 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12656 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12657 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12658 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12659 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12660 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12661 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12663 return (PARSER_OK
);
12666 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12668 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12670 u32
*digest
= (u32
*) hash_buf
->digest
;
12672 salt_t
*salt
= hash_buf
->salt
;
12674 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12675 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12676 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12677 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12678 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12680 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12682 uint salt_len
= input_len
- 40 - 1;
12684 char *salt_buf
= input_buf
+ 40 + 1;
12686 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12688 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12690 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12692 salt
->salt_len
= salt_len
;
12694 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12696 return (PARSER_OK
);
12699 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12701 u32
*digest
= (u32
*) hash_buf
->digest
;
12703 salt_t
*salt
= hash_buf
->salt
;
12705 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12707 if (input_len
== 0)
12709 log_error ("TrueCrypt container not specified");
12714 FILE *fp
= fopen (input_buf
, "rb");
12718 log_error ("%s: %s", input_buf
, strerror (errno
));
12723 char buf
[512] = { 0 };
12725 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12729 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12731 memcpy (tc
->salt_buf
, buf
, 64);
12733 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12735 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12737 salt
->salt_len
= 4;
12739 salt
->salt_iter
= 1000 - 1;
12741 digest
[0] = tc
->data_buf
[0];
12743 return (PARSER_OK
);
12746 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12748 u32
*digest
= (u32
*) hash_buf
->digest
;
12750 salt_t
*salt
= hash_buf
->salt
;
12752 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12754 if (input_len
== 0)
12756 log_error ("TrueCrypt container not specified");
12761 FILE *fp
= fopen (input_buf
, "rb");
12765 log_error ("%s: %s", input_buf
, strerror (errno
));
12770 char buf
[512] = { 0 };
12772 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12776 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12778 memcpy (tc
->salt_buf
, buf
, 64);
12780 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12782 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12784 salt
->salt_len
= 4;
12786 salt
->salt_iter
= 2000 - 1;
12788 digest
[0] = tc
->data_buf
[0];
12790 return (PARSER_OK
);
12793 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12795 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12797 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12799 u32
*digest
= (u32
*) hash_buf
->digest
;
12801 salt_t
*salt
= hash_buf
->salt
;
12803 char *salt_pos
= input_buf
+ 6;
12805 char *hash_pos
= strchr (salt_pos
, '$');
12807 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12809 uint salt_len
= hash_pos
- salt_pos
;
12811 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12813 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12815 salt
->salt_len
= salt_len
;
12817 salt
->salt_iter
= 1000;
12821 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12823 return (PARSER_OK
);
12826 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12828 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12830 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12832 u32
*digest
= (u32
*) hash_buf
->digest
;
12834 salt_t
*salt
= hash_buf
->salt
;
12836 char *iter_pos
= input_buf
+ 7;
12838 char *salt_pos
= strchr (iter_pos
, '$');
12840 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12844 char *hash_pos
= strchr (salt_pos
, '$');
12846 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12848 uint salt_len
= hash_pos
- salt_pos
;
12850 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12852 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12854 salt
->salt_len
= salt_len
;
12856 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12858 salt
->salt_sign
[0] = atoi (salt_iter
);
12860 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12864 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12866 digest
[0] = byte_swap_32 (digest
[0]);
12867 digest
[1] = byte_swap_32 (digest
[1]);
12868 digest
[2] = byte_swap_32 (digest
[2]);
12869 digest
[3] = byte_swap_32 (digest
[3]);
12870 digest
[4] = byte_swap_32 (digest
[4]);
12872 return (PARSER_OK
);
12875 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12877 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12879 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12881 u32
*digest
= (u32
*) hash_buf
->digest
;
12883 salt_t
*salt
= hash_buf
->salt
;
12885 char *iter_pos
= input_buf
+ 9;
12887 char *salt_pos
= strchr (iter_pos
, '$');
12889 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12893 char *hash_pos
= strchr (salt_pos
, '$');
12895 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12897 uint salt_len
= hash_pos
- salt_pos
;
12899 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12901 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12903 salt
->salt_len
= salt_len
;
12905 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12907 salt
->salt_sign
[0] = atoi (salt_iter
);
12909 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12913 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12915 digest
[0] = byte_swap_32 (digest
[0]);
12916 digest
[1] = byte_swap_32 (digest
[1]);
12917 digest
[2] = byte_swap_32 (digest
[2]);
12918 digest
[3] = byte_swap_32 (digest
[3]);
12919 digest
[4] = byte_swap_32 (digest
[4]);
12920 digest
[5] = byte_swap_32 (digest
[5]);
12921 digest
[6] = byte_swap_32 (digest
[6]);
12922 digest
[7] = byte_swap_32 (digest
[7]);
12924 return (PARSER_OK
);
12927 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12929 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12931 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12933 u64
*digest
= (u64
*) hash_buf
->digest
;
12935 salt_t
*salt
= hash_buf
->salt
;
12937 char *iter_pos
= input_buf
+ 9;
12939 char *salt_pos
= strchr (iter_pos
, '$');
12941 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12945 char *hash_pos
= strchr (salt_pos
, '$');
12947 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12949 uint salt_len
= hash_pos
- salt_pos
;
12951 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12953 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12955 salt
->salt_len
= salt_len
;
12957 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12959 salt
->salt_sign
[0] = atoi (salt_iter
);
12961 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12965 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12967 digest
[0] = byte_swap_64 (digest
[0]);
12968 digest
[1] = byte_swap_64 (digest
[1]);
12969 digest
[2] = byte_swap_64 (digest
[2]);
12970 digest
[3] = byte_swap_64 (digest
[3]);
12971 digest
[4] = byte_swap_64 (digest
[4]);
12972 digest
[5] = byte_swap_64 (digest
[5]);
12973 digest
[6] = byte_swap_64 (digest
[6]);
12974 digest
[7] = byte_swap_64 (digest
[7]);
12976 return (PARSER_OK
);
12979 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12981 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12983 u32
*digest
= (u32
*) hash_buf
->digest
;
12985 salt_t
*salt
= hash_buf
->salt
;
12987 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12993 char *iterations_pos
= input_buf
;
12995 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12997 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12999 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13001 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13005 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13007 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13009 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13011 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13013 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13015 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13020 * pbkdf2 iterations
13023 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13026 * handle salt encoding
13029 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13031 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13033 const char p0
= saltbuf_pos
[i
+ 0];
13034 const char p1
= saltbuf_pos
[i
+ 1];
13036 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13037 | hex_convert (p0
) << 4;
13040 salt
->salt_len
= saltbuf_len
/ 2;
13043 * handle cipher encoding
13046 uint
*tmp
= (uint
*) mymalloc (32);
13048 char *cipherbuf_ptr
= (char *) tmp
;
13050 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13052 const char p0
= cipherbuf_pos
[i
+ 0];
13053 const char p1
= cipherbuf_pos
[i
+ 1];
13055 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13056 | hex_convert (p0
) << 4;
13059 // iv is stored at salt_buf 4 (length 16)
13060 // data is stored at salt_buf 8 (length 16)
13062 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13063 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13064 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13065 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13067 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13068 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13069 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13070 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13074 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13076 const char p0
= cipherbuf_pos
[j
+ 0];
13077 const char p1
= cipherbuf_pos
[j
+ 1];
13079 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13080 | hex_convert (p0
) << 4;
13087 digest
[0] = 0x10101010;
13088 digest
[1] = 0x10101010;
13089 digest
[2] = 0x10101010;
13090 digest
[3] = 0x10101010;
13092 return (PARSER_OK
);
13095 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13097 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13099 u32
*digest
= (u32
*) hash_buf
->digest
;
13101 salt_t
*salt
= hash_buf
->salt
;
13103 char *hashbuf_pos
= input_buf
;
13105 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13107 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13109 uint hash_len
= iterations_pos
- hashbuf_pos
;
13111 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13115 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13117 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13119 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13123 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13125 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13127 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13129 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13131 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13133 salt
->salt_len
= salt_len
;
13135 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13137 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13138 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13139 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13140 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13142 return (PARSER_OK
);
13145 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13147 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13149 u32
*digest
= (u32
*) hash_buf
->digest
;
13151 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13152 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13153 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13154 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13155 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13156 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13157 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13158 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13160 digest
[0] = byte_swap_32 (digest
[0]);
13161 digest
[1] = byte_swap_32 (digest
[1]);
13162 digest
[2] = byte_swap_32 (digest
[2]);
13163 digest
[3] = byte_swap_32 (digest
[3]);
13164 digest
[4] = byte_swap_32 (digest
[4]);
13165 digest
[5] = byte_swap_32 (digest
[5]);
13166 digest
[6] = byte_swap_32 (digest
[6]);
13167 digest
[7] = byte_swap_32 (digest
[7]);
13169 return (PARSER_OK
);
13172 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13174 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13176 u32
*digest
= (u32
*) hash_buf
->digest
;
13178 salt_t
*salt
= hash_buf
->salt
;
13180 char *salt_pos
= input_buf
+ 3;
13182 uint iterations_len
= 0;
13184 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13188 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13190 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13191 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13195 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13199 iterations_len
+= 8;
13203 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13206 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13208 char *hash_pos
= strchr (salt_pos
, '$');
13210 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13212 uint salt_len
= hash_pos
- salt_pos
;
13214 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13216 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13218 salt
->salt_len
= salt_len
;
13222 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13224 return (PARSER_OK
);
13227 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13229 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13231 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13233 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13235 u64
*digest
= (u64
*) hash_buf
->digest
;
13237 salt_t
*salt
= hash_buf
->salt
;
13239 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13241 char *iter_pos
= input_buf
+ 4;
13243 char *salt_pos
= strchr (iter_pos
, '$');
13245 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13249 char *hash_pos
= strchr (salt_pos
, '$');
13251 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13253 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13257 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13258 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13259 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13260 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13261 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13262 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13263 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13264 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13266 uint salt_len
= hash_pos
- salt_pos
- 1;
13268 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13270 salt
->salt_len
= salt_len
/ 2;
13272 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13273 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13274 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13275 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13276 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13277 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13278 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13279 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13281 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13282 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13283 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13284 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13285 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13286 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13287 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13288 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13289 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13290 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13292 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13294 salt
->salt_iter
= atoi (iter_pos
) - 1;
13296 return (PARSER_OK
);
13299 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13301 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13303 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13305 u32
*digest
= (u32
*) hash_buf
->digest
;
13307 salt_t
*salt
= hash_buf
->salt
;
13309 char *salt_pos
= input_buf
+ 14;
13311 char *hash_pos
= strchr (salt_pos
, '*');
13313 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13317 uint salt_len
= hash_pos
- salt_pos
- 1;
13319 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13321 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13323 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13325 salt
->salt_len
= salt_len
;
13327 u8 tmp_buf
[100] = { 0 };
13329 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13331 memcpy (digest
, tmp_buf
, 32);
13333 digest
[0] = byte_swap_32 (digest
[0]);
13334 digest
[1] = byte_swap_32 (digest
[1]);
13335 digest
[2] = byte_swap_32 (digest
[2]);
13336 digest
[3] = byte_swap_32 (digest
[3]);
13337 digest
[4] = byte_swap_32 (digest
[4]);
13338 digest
[5] = byte_swap_32 (digest
[5]);
13339 digest
[6] = byte_swap_32 (digest
[6]);
13340 digest
[7] = byte_swap_32 (digest
[7]);
13342 digest
[0] -= SHA256M_A
;
13343 digest
[1] -= SHA256M_B
;
13344 digest
[2] -= SHA256M_C
;
13345 digest
[3] -= SHA256M_D
;
13346 digest
[4] -= SHA256M_E
;
13347 digest
[5] -= SHA256M_F
;
13348 digest
[6] -= SHA256M_G
;
13349 digest
[7] -= SHA256M_H
;
13351 return (PARSER_OK
);
13354 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13356 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13358 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13360 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13362 u64
*digest
= (u64
*) hash_buf
->digest
;
13364 salt_t
*salt
= hash_buf
->salt
;
13366 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13368 char *iter_pos
= input_buf
+ 19;
13370 char *salt_pos
= strchr (iter_pos
, '.');
13372 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13376 char *hash_pos
= strchr (salt_pos
, '.');
13378 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13380 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13384 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13385 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13386 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13387 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13388 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13389 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13390 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13391 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13393 uint salt_len
= hash_pos
- salt_pos
- 1;
13397 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13401 for (i
= 0; i
< salt_len
; i
++)
13403 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13406 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13407 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13409 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13411 salt
->salt_len
= salt_len
;
13413 salt
->salt_iter
= atoi (iter_pos
) - 1;
13415 return (PARSER_OK
);
13418 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13420 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13422 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13424 u64
*digest
= (u64
*) hash_buf
->digest
;
13426 salt_t
*salt
= hash_buf
->salt
;
13428 u8 tmp_buf
[120] = { 0 };
13430 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13432 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13434 memcpy (digest
, tmp_buf
, 64);
13436 digest
[0] = byte_swap_64 (digest
[0]);
13437 digest
[1] = byte_swap_64 (digest
[1]);
13438 digest
[2] = byte_swap_64 (digest
[2]);
13439 digest
[3] = byte_swap_64 (digest
[3]);
13440 digest
[4] = byte_swap_64 (digest
[4]);
13441 digest
[5] = byte_swap_64 (digest
[5]);
13442 digest
[6] = byte_swap_64 (digest
[6]);
13443 digest
[7] = byte_swap_64 (digest
[7]);
13445 digest
[0] -= SHA512M_A
;
13446 digest
[1] -= SHA512M_B
;
13447 digest
[2] -= SHA512M_C
;
13448 digest
[3] -= SHA512M_D
;
13449 digest
[4] -= SHA512M_E
;
13450 digest
[5] -= SHA512M_F
;
13451 digest
[6] -= SHA512M_G
;
13452 digest
[7] -= SHA512M_H
;
13454 int salt_len
= tmp_len
- 64;
13456 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13458 salt
->salt_len
= salt_len
;
13460 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13462 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13464 char *ptr
= (char *) salt
->salt_buf
;
13466 ptr
[salt
->salt_len
] = 0x80;
13469 return (PARSER_OK
);
13472 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13474 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13476 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13480 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13483 u32
*digest
= (u32
*) hash_buf
->digest
;
13485 salt_t
*salt
= hash_buf
->salt
;
13487 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13488 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13489 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13490 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13492 digest
[0] = byte_swap_32 (digest
[0]);
13493 digest
[1] = byte_swap_32 (digest
[1]);
13494 digest
[2] = byte_swap_32 (digest
[2]);
13495 digest
[3] = byte_swap_32 (digest
[3]);
13497 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13499 uint salt_len
= input_len
- 32 - 1;
13501 char *salt_buf
= input_buf
+ 32 + 1;
13503 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13505 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13507 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13509 salt
->salt_len
= salt_len
;
13511 return (PARSER_OK
);
13514 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13516 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13518 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13522 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13525 u32
*digest
= (u32
*) hash_buf
->digest
;
13527 salt_t
*salt
= hash_buf
->salt
;
13529 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13530 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13531 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13532 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13533 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13535 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13537 uint salt_len
= input_len
- 40 - 1;
13539 char *salt_buf
= input_buf
+ 40 + 1;
13541 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13543 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13545 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13547 salt
->salt_len
= salt_len
;
13549 return (PARSER_OK
);
13552 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13554 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13556 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13560 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13563 u32
*digest
= (u32
*) hash_buf
->digest
;
13565 salt_t
*salt
= hash_buf
->salt
;
13567 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13568 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13569 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13570 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13571 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13572 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13573 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13574 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13576 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13578 uint salt_len
= input_len
- 64 - 1;
13580 char *salt_buf
= input_buf
+ 64 + 1;
13582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13584 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13586 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13588 salt
->salt_len
= salt_len
;
13590 return (PARSER_OK
);
13593 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13595 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13597 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13601 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13604 u64
*digest
= (u64
*) hash_buf
->digest
;
13606 salt_t
*salt
= hash_buf
->salt
;
13608 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13609 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13610 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13611 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13612 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13613 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13614 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13615 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13617 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13619 uint salt_len
= input_len
- 128 - 1;
13621 char *salt_buf
= input_buf
+ 128 + 1;
13623 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13625 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13627 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13629 salt
->salt_len
= salt_len
;
13631 return (PARSER_OK
);
13634 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13636 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13638 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13640 u32
*digest
= (u32
*) hash_buf
->digest
;
13642 salt_t
*salt
= hash_buf
->salt
;
13644 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13650 char *user_pos
= input_buf
+ 10 + 1;
13652 char *realm_pos
= strchr (user_pos
, '$');
13654 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13656 uint user_len
= realm_pos
- user_pos
;
13658 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13662 char *salt_pos
= strchr (realm_pos
, '$');
13664 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13666 uint realm_len
= salt_pos
- realm_pos
;
13668 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13672 char *data_pos
= strchr (salt_pos
, '$');
13674 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13676 uint salt_len
= data_pos
- salt_pos
;
13678 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13682 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13684 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13690 memcpy (krb5pa
->user
, user_pos
, user_len
);
13691 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13692 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13694 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13696 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13698 const char p0
= data_pos
[i
+ 0];
13699 const char p1
= data_pos
[i
+ 1];
13701 *timestamp_ptr
++ = hex_convert (p1
) << 0
13702 | hex_convert (p0
) << 4;
13705 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13707 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13709 const char p0
= data_pos
[i
+ 0];
13710 const char p1
= data_pos
[i
+ 1];
13712 *checksum_ptr
++ = hex_convert (p1
) << 0
13713 | hex_convert (p0
) << 4;
13717 * copy some data to generic buffers to make sorting happy
13720 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13721 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13722 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13723 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13724 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13725 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13726 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13727 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13728 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13730 salt
->salt_len
= 36;
13732 digest
[0] = krb5pa
->checksum
[0];
13733 digest
[1] = krb5pa
->checksum
[1];
13734 digest
[2] = krb5pa
->checksum
[2];
13735 digest
[3] = krb5pa
->checksum
[3];
13737 return (PARSER_OK
);
13740 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13742 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13744 u32
*digest
= (u32
*) hash_buf
->digest
;
13746 salt_t
*salt
= hash_buf
->salt
;
13752 char *salt_pos
= input_buf
;
13754 char *hash_pos
= strchr (salt_pos
, '$');
13756 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13758 uint salt_len
= hash_pos
- salt_pos
;
13760 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13764 uint hash_len
= input_len
- 1 - salt_len
;
13766 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13774 for (uint i
= 0; i
< salt_len
; i
++)
13776 if (salt_pos
[i
] == ' ') continue;
13781 // SAP user names cannot be longer than 12 characters
13782 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13784 // SAP user name cannot start with ! or ?
13785 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13791 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13793 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13795 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13797 salt
->salt_len
= salt_len
;
13799 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13800 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13804 digest
[0] = byte_swap_32 (digest
[0]);
13805 digest
[1] = byte_swap_32 (digest
[1]);
13807 return (PARSER_OK
);
13810 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13812 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13814 u32
*digest
= (u32
*) hash_buf
->digest
;
13816 salt_t
*salt
= hash_buf
->salt
;
13822 char *salt_pos
= input_buf
;
13824 char *hash_pos
= strchr (salt_pos
, '$');
13826 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13828 uint salt_len
= hash_pos
- salt_pos
;
13830 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13834 uint hash_len
= input_len
- 1 - salt_len
;
13836 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13844 for (uint i
= 0; i
< salt_len
; i
++)
13846 if (salt_pos
[i
] == ' ') continue;
13851 // SAP user names cannot be longer than 12 characters
13852 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13853 // so far nobody complained so we stay with this because it helps in optimization
13854 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13856 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13858 // SAP user name cannot start with ! or ?
13859 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13865 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13867 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13869 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13871 salt
->salt_len
= salt_len
;
13873 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13874 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13875 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13876 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13877 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13879 return (PARSER_OK
);
13882 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13884 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13886 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13888 u64
*digest
= (u64
*) hash_buf
->digest
;
13890 salt_t
*salt
= hash_buf
->salt
;
13892 char *iter_pos
= input_buf
+ 3;
13894 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13896 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13898 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13900 salt
->salt_iter
= salt_iter
;
13902 char *salt_pos
= iter_pos
+ 1;
13906 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13908 salt
->salt_len
= salt_len
;
13910 char *hash_pos
= salt_pos
+ salt_len
;
13912 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13916 char *tmp
= (char *) salt
->salt_buf_pc
;
13918 tmp
[0] = hash_pos
[42];
13922 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13923 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13924 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13925 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13931 return (PARSER_OK
);
13934 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13936 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13938 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13940 u32
*digest
= (u32
*) hash_buf
->digest
;
13942 salt_t
*salt
= hash_buf
->salt
;
13944 char *salt_buf
= input_buf
+ 6;
13946 uint salt_len
= 16;
13948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13954 salt
->salt_len
= salt_len
;
13956 char *hash_pos
= input_buf
+ 6 + 16;
13958 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13959 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13960 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13961 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13962 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13963 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13964 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13965 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13967 return (PARSER_OK
);
13970 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13972 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13974 u32
*digest
= (u32
*) hash_buf
->digest
;
13976 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13977 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13981 return (PARSER_OK
);
13984 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13986 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13988 u32
*digest
= (u32
*) hash_buf
->digest
;
13990 salt_t
*salt
= hash_buf
->salt
;
13992 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13994 char *saltbuf_pos
= input_buf
;
13996 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13998 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14000 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14002 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14003 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14005 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14009 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14011 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14013 char *salt_ptr
= (char *) saltbuf_pos
;
14014 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14019 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14021 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14024 rakp_ptr
[j
] = 0x80;
14026 rakp
->salt_len
= j
;
14028 for (i
= 0; i
< 64; i
++)
14030 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14033 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14034 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14035 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14036 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14037 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14038 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14039 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14040 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14042 salt
->salt_len
= 32; // muss min. 32 haben
14044 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14045 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14046 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14047 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14048 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14050 return (PARSER_OK
);
14053 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14055 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14057 u32
*digest
= (u32
*) hash_buf
->digest
;
14059 salt_t
*salt
= hash_buf
->salt
;
14061 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14063 char *salt_pos
= input_buf
+ 1;
14065 memcpy (salt
->salt_buf
, salt_pos
, 8);
14067 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14068 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14070 salt
->salt_len
= 8;
14072 char *hash_pos
= salt_pos
+ 8;
14074 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14075 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14076 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14077 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14078 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14080 digest
[0] -= SHA1M_A
;
14081 digest
[1] -= SHA1M_B
;
14082 digest
[2] -= SHA1M_C
;
14083 digest
[3] -= SHA1M_D
;
14084 digest
[4] -= SHA1M_E
;
14086 return (PARSER_OK
);
14089 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14091 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14093 u32
*digest
= (u32
*) hash_buf
->digest
;
14095 salt_t
*salt
= hash_buf
->salt
;
14097 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14098 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14099 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14100 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14102 digest
[0] = byte_swap_32 (digest
[0]);
14103 digest
[1] = byte_swap_32 (digest
[1]);
14104 digest
[2] = byte_swap_32 (digest
[2]);
14105 digest
[3] = byte_swap_32 (digest
[3]);
14107 digest
[0] -= MD5M_A
;
14108 digest
[1] -= MD5M_B
;
14109 digest
[2] -= MD5M_C
;
14110 digest
[3] -= MD5M_D
;
14112 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14114 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14116 u32
*salt_buf
= salt
->salt_buf
;
14118 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14119 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14120 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14121 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14123 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14124 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14125 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14126 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14128 salt
->salt_len
= 16 + 1;
14130 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14132 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14134 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14136 return (PARSER_OK
);
14139 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14141 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14143 u32
*digest
= (u32
*) hash_buf
->digest
;
14145 salt_t
*salt
= hash_buf
->salt
;
14147 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14153 char *hashbuf_pos
= input_buf
;
14155 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14157 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14159 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14161 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14165 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14167 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14169 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14171 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14175 char *databuf_pos
= strchr (iteration_pos
, ':');
14177 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14179 const uint iteration_len
= databuf_pos
- iteration_pos
;
14181 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14182 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14184 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14186 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14187 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14193 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14194 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14195 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14196 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14197 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14198 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14199 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14200 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14204 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14206 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14208 const char p0
= saltbuf_pos
[i
+ 0];
14209 const char p1
= saltbuf_pos
[i
+ 1];
14211 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14212 | hex_convert (p0
) << 4;
14215 salt
->salt_buf
[4] = 0x01000000;
14216 salt
->salt_buf
[5] = 0x80;
14218 salt
->salt_len
= saltbuf_len
/ 2;
14222 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14226 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14228 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14230 const char p0
= databuf_pos
[i
+ 0];
14231 const char p1
= databuf_pos
[i
+ 1];
14233 *databuf_ptr
++ = hex_convert (p1
) << 0
14234 | hex_convert (p0
) << 4;
14237 *databuf_ptr
++ = 0x80;
14239 for (uint i
= 0; i
< 512; i
++)
14241 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14244 cloudkey
->data_len
= databuf_len
/ 2;
14246 return (PARSER_OK
);
14249 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14251 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14253 u32
*digest
= (u32
*) hash_buf
->digest
;
14255 salt_t
*salt
= hash_buf
->salt
;
14261 char *hashbuf_pos
= input_buf
;
14263 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14265 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14267 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14269 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14273 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14275 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14277 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14279 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14281 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14285 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14287 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14289 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14291 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14293 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14297 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14299 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14300 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14302 // ok, the plan for this algorithm is the following:
14303 // we have 2 salts here, the domain-name and a random salt
14304 // while both are used in the initial transformation,
14305 // only the random salt is used in the following iterations
14306 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14307 // and one that includes only the real salt (stored into salt_buf[]).
14308 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14310 u8 tmp_buf
[100] = { 0 };
14312 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14314 memcpy (digest
, tmp_buf
, 20);
14316 digest
[0] = byte_swap_32 (digest
[0]);
14317 digest
[1] = byte_swap_32 (digest
[1]);
14318 digest
[2] = byte_swap_32 (digest
[2]);
14319 digest
[3] = byte_swap_32 (digest
[3]);
14320 digest
[4] = byte_swap_32 (digest
[4]);
14324 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14326 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14328 char *len_ptr
= NULL
;
14330 for (uint i
= 0; i
< domainbuf_len
; i
++)
14332 if (salt_buf_pc_ptr
[i
] == '.')
14334 len_ptr
= &salt_buf_pc_ptr
[i
];
14344 salt
->salt_buf_pc
[7] = domainbuf_len
;
14348 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14350 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14352 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14354 salt
->salt_len
= salt_len
;
14358 salt
->salt_iter
= atoi (iteration_pos
);
14360 return (PARSER_OK
);
14363 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14365 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14367 u32
*digest
= (u32
*) hash_buf
->digest
;
14369 salt_t
*salt
= hash_buf
->salt
;
14371 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14372 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14373 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14374 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14375 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14377 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14379 uint salt_len
= input_len
- 40 - 1;
14381 char *salt_buf
= input_buf
+ 40 + 1;
14383 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14385 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14387 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14389 salt
->salt_len
= salt_len
;
14391 return (PARSER_OK
);
14394 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14396 const u8 ascii_to_ebcdic
[] =
14398 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14399 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14400 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14401 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14402 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14403 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14404 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14405 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14406 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14407 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14408 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14409 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14410 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14411 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14412 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14413 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14416 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14418 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14420 u32
*digest
= (u32
*) hash_buf
->digest
;
14422 salt_t
*salt
= hash_buf
->salt
;
14424 char *salt_pos
= input_buf
+ 6 + 1;
14426 char *digest_pos
= strchr (salt_pos
, '*');
14428 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14430 uint salt_len
= digest_pos
- salt_pos
;
14432 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14434 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14436 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14440 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14441 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14443 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14447 salt
->salt_len
= salt_len
;
14449 for (uint i
= 0; i
< salt_len
; i
++)
14451 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14453 for (uint i
= salt_len
; i
< 8; i
++)
14455 salt_buf_pc_ptr
[i
] = 0x40;
14460 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14462 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14463 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14465 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14466 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14468 digest
[0] = byte_swap_32 (digest
[0]);
14469 digest
[1] = byte_swap_32 (digest
[1]);
14471 IP (digest
[0], digest
[1], tt
);
14473 digest
[0] = rotr32 (digest
[0], 29);
14474 digest
[1] = rotr32 (digest
[1], 29);
14478 return (PARSER_OK
);
14481 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14483 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14485 u32
*digest
= (u32
*) hash_buf
->digest
;
14487 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14488 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14489 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14490 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14492 digest
[0] = byte_swap_32 (digest
[0]);
14493 digest
[1] = byte_swap_32 (digest
[1]);
14494 digest
[2] = byte_swap_32 (digest
[2]);
14495 digest
[3] = byte_swap_32 (digest
[3]);
14497 return (PARSER_OK
);
14500 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14502 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14504 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14506 u32
*digest
= (u32
*) hash_buf
->digest
;
14508 salt_t
*salt
= hash_buf
->salt
;
14510 u8 tmp_buf
[120] = { 0 };
14512 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14514 tmp_buf
[3] += -4; // dont ask!
14516 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14518 salt
->salt_len
= 5;
14520 memcpy (digest
, tmp_buf
+ 5, 9);
14522 // yes, only 9 byte are needed to crack, but 10 to display
14524 salt
->salt_buf_pc
[7] = input_buf
[20];
14526 return (PARSER_OK
);
14529 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14531 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14533 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14535 u32
*digest
= (u32
*) hash_buf
->digest
;
14537 salt_t
*salt
= hash_buf
->salt
;
14539 u8 tmp_buf
[120] = { 0 };
14541 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14543 tmp_buf
[3] += -4; // dont ask!
14547 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14549 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)
14553 char tmp_iter_buf
[11] = { 0 };
14555 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14557 tmp_iter_buf
[10] = 0;
14559 salt
->salt_iter
= atoi (tmp_iter_buf
);
14561 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14563 return (PARSER_SALT_ITERATION
);
14566 salt
->salt_iter
--; // first round in init
14568 // 2 additional bytes for display only
14570 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14571 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14575 memcpy (digest
, tmp_buf
+ 28, 8);
14577 digest
[0] = byte_swap_32 (digest
[0]);
14578 digest
[1] = byte_swap_32 (digest
[1]);
14582 return (PARSER_OK
);
14585 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14587 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14589 u32
*digest
= (u32
*) hash_buf
->digest
;
14591 salt_t
*salt
= hash_buf
->salt
;
14593 char *salt_buf_pos
= input_buf
;
14595 char *hash_buf_pos
= salt_buf_pos
+ 6;
14597 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14598 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14599 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14600 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14601 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14602 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14603 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14604 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14606 digest
[0] -= SHA256M_A
;
14607 digest
[1] -= SHA256M_B
;
14608 digest
[2] -= SHA256M_C
;
14609 digest
[3] -= SHA256M_D
;
14610 digest
[4] -= SHA256M_E
;
14611 digest
[5] -= SHA256M_F
;
14612 digest
[6] -= SHA256M_G
;
14613 digest
[7] -= SHA256M_H
;
14615 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14617 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14619 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14621 salt
->salt_len
= salt_len
;
14623 return (PARSER_OK
);
14626 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14628 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14630 u32
*digest
= (u32
*) hash_buf
->digest
;
14632 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14634 salt_t
*salt
= hash_buf
->salt
;
14636 char *salt_buf
= input_buf
+ 6;
14638 char *digest_buf
= strchr (salt_buf
, '$');
14640 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14642 uint salt_len
= digest_buf
- salt_buf
;
14644 digest_buf
++; // skip the '$' symbol
14646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14652 salt
->salt_len
= salt_len
;
14654 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14655 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14656 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14657 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14659 digest
[0] = byte_swap_32 (digest
[0]);
14660 digest
[1] = byte_swap_32 (digest
[1]);
14661 digest
[2] = byte_swap_32 (digest
[2]);
14662 digest
[3] = byte_swap_32 (digest
[3]);
14664 digest
[0] -= MD5M_A
;
14665 digest
[1] -= MD5M_B
;
14666 digest
[2] -= MD5M_C
;
14667 digest
[3] -= MD5M_D
;
14669 return (PARSER_OK
);
14672 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14674 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14676 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14678 u32
*digest
= (u32
*) hash_buf
->digest
;
14680 salt_t
*salt
= hash_buf
->salt
;
14682 char *salt_buf
= input_buf
+ 3;
14684 char *digest_buf
= strchr (salt_buf
, '$');
14686 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14688 uint salt_len
= digest_buf
- salt_buf
;
14690 digest_buf
++; // skip the '$' symbol
14692 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14694 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14696 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14698 salt_buf_ptr
[salt_len
] = 0x2d;
14700 salt
->salt_len
= salt_len
+ 1;
14702 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14703 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14704 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14705 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14707 digest
[0] = byte_swap_32 (digest
[0]);
14708 digest
[1] = byte_swap_32 (digest
[1]);
14709 digest
[2] = byte_swap_32 (digest
[2]);
14710 digest
[3] = byte_swap_32 (digest
[3]);
14712 digest
[0] -= MD5M_A
;
14713 digest
[1] -= MD5M_B
;
14714 digest
[2] -= MD5M_C
;
14715 digest
[3] -= MD5M_D
;
14717 return (PARSER_OK
);
14720 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14722 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14724 u32
*digest
= (u32
*) hash_buf
->digest
;
14726 salt_t
*salt
= hash_buf
->salt
;
14728 u8 tmp_buf
[100] = { 0 };
14730 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14732 memcpy (digest
, tmp_buf
, 20);
14734 digest
[0] = byte_swap_32 (digest
[0]);
14735 digest
[1] = byte_swap_32 (digest
[1]);
14736 digest
[2] = byte_swap_32 (digest
[2]);
14737 digest
[3] = byte_swap_32 (digest
[3]);
14738 digest
[4] = byte_swap_32 (digest
[4]);
14740 digest
[0] -= SHA1M_A
;
14741 digest
[1] -= SHA1M_B
;
14742 digest
[2] -= SHA1M_C
;
14743 digest
[3] -= SHA1M_D
;
14744 digest
[4] -= SHA1M_E
;
14746 salt
->salt_buf
[0] = 0x80;
14748 salt
->salt_len
= 0;
14750 return (PARSER_OK
);
14753 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14755 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14757 u32
*digest
= (u32
*) hash_buf
->digest
;
14759 salt_t
*salt
= hash_buf
->salt
;
14761 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14762 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14763 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14764 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14766 digest
[0] = byte_swap_32 (digest
[0]);
14767 digest
[1] = byte_swap_32 (digest
[1]);
14768 digest
[2] = byte_swap_32 (digest
[2]);
14769 digest
[3] = byte_swap_32 (digest
[3]);
14771 digest
[0] -= MD5M_A
;
14772 digest
[1] -= MD5M_B
;
14773 digest
[2] -= MD5M_C
;
14774 digest
[3] -= MD5M_D
;
14776 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14778 uint salt_len
= input_len
- 32 - 1;
14780 char *salt_buf
= input_buf
+ 32 + 1;
14782 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14784 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14786 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14789 * add static "salt" part
14792 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14796 salt
->salt_len
= salt_len
;
14798 return (PARSER_OK
);
14801 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14803 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14805 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14807 u32
*digest
= (u32
*) hash_buf
->digest
;
14809 salt_t
*salt
= hash_buf
->salt
;
14811 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14817 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14819 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14821 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14823 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14825 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14829 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14831 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14833 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14835 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14839 char *keybuf_pos
= strchr (keylen_pos
, '$');
14841 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14843 uint keylen_len
= keybuf_pos
- keylen_pos
;
14845 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14849 char *databuf_pos
= strchr (keybuf_pos
, '$');
14851 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14853 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14855 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14859 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14861 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14867 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14868 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14869 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14870 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14872 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14873 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14874 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14875 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14877 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14878 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14879 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14880 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14882 salt
->salt_len
= 16;
14883 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14885 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14887 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14890 return (PARSER_OK
);
14893 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14895 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14897 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14899 u32
*digest
= (u32
*) hash_buf
->digest
;
14901 salt_t
*salt
= hash_buf
->salt
;
14907 // first is the N salt parameter
14909 char *N_pos
= input_buf
+ 6;
14911 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14915 salt
->scrypt_N
= atoi (N_pos
);
14919 char *r_pos
= strchr (N_pos
, ':');
14921 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14925 salt
->scrypt_r
= atoi (r_pos
);
14929 char *p_pos
= strchr (r_pos
, ':');
14931 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14935 salt
->scrypt_p
= atoi (p_pos
);
14939 char *saltbuf_pos
= strchr (p_pos
, ':');
14941 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14945 char *hash_pos
= strchr (saltbuf_pos
, ':');
14947 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14953 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14955 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14957 u8 tmp_buf
[33] = { 0 };
14959 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14961 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14963 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14965 salt
->salt_len
= tmp_len
;
14966 salt
->salt_iter
= 1;
14968 // digest - base64 decode
14970 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14972 tmp_len
= input_len
- (hash_pos
- input_buf
);
14974 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14976 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14978 memcpy (digest
, tmp_buf
, 32);
14980 return (PARSER_OK
);
14983 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14985 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14987 u32
*digest
= (u32
*) hash_buf
->digest
;
14989 salt_t
*salt
= hash_buf
->salt
;
14995 char decrypted
[76] = { 0 }; // iv + hash
14997 juniper_decrypt_hash (input_buf
, decrypted
);
14999 char *md5crypt_hash
= decrypted
+ 12;
15001 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15003 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15005 char *salt_pos
= md5crypt_hash
+ 3;
15007 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15009 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15011 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15015 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15017 return (PARSER_OK
);
15020 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15022 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15024 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15026 u32
*digest
= (u32
*) hash_buf
->digest
;
15028 salt_t
*salt
= hash_buf
->salt
;
15030 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15036 // first is *raw* salt
15038 char *salt_pos
= input_buf
+ 3;
15040 char *hash_pos
= strchr (salt_pos
, '$');
15042 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15044 uint salt_len
= hash_pos
- salt_pos
;
15046 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15050 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15052 memcpy (salt_buf_ptr
, salt_pos
, 14);
15054 salt_buf_ptr
[17] = 0x01;
15055 salt_buf_ptr
[18] = 0x80;
15057 // add some stuff to normal salt to make sorted happy
15059 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15060 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15061 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15062 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15064 salt
->salt_len
= salt_len
;
15065 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15067 // base64 decode hash
15069 u8 tmp_buf
[100] = { 0 };
15071 uint hash_len
= input_len
- 3 - salt_len
- 1;
15073 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15075 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15077 memcpy (digest
, tmp_buf
, 32);
15079 digest
[0] = byte_swap_32 (digest
[0]);
15080 digest
[1] = byte_swap_32 (digest
[1]);
15081 digest
[2] = byte_swap_32 (digest
[2]);
15082 digest
[3] = byte_swap_32 (digest
[3]);
15083 digest
[4] = byte_swap_32 (digest
[4]);
15084 digest
[5] = byte_swap_32 (digest
[5]);
15085 digest
[6] = byte_swap_32 (digest
[6]);
15086 digest
[7] = byte_swap_32 (digest
[7]);
15088 return (PARSER_OK
);
15091 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15093 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15095 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15097 u32
*digest
= (u32
*) hash_buf
->digest
;
15099 salt_t
*salt
= hash_buf
->salt
;
15105 // first is *raw* salt
15107 char *salt_pos
= input_buf
+ 3;
15109 char *hash_pos
= strchr (salt_pos
, '$');
15111 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15113 uint salt_len
= hash_pos
- salt_pos
;
15115 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15117 salt
->salt_len
= salt_len
;
15120 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15122 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15123 salt_buf_ptr
[salt_len
] = 0;
15125 // base64 decode hash
15127 u8 tmp_buf
[100] = { 0 };
15129 uint hash_len
= input_len
- 3 - salt_len
- 1;
15131 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15133 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15135 memcpy (digest
, tmp_buf
, 32);
15138 salt
->scrypt_N
= 16384;
15139 salt
->scrypt_r
= 1;
15140 salt
->scrypt_p
= 1;
15141 salt
->salt_iter
= 1;
15143 return (PARSER_OK
);
15146 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15148 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15150 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15152 u32
*digest
= (u32
*) hash_buf
->digest
;
15154 salt_t
*salt
= hash_buf
->salt
;
15156 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15162 char *version_pos
= input_buf
+ 8 + 1;
15164 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15166 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15168 u32 version_len
= verifierHashSize_pos
- version_pos
;
15170 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15172 verifierHashSize_pos
++;
15174 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15176 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15178 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15180 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15184 char *saltSize_pos
= strchr (keySize_pos
, '*');
15186 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15188 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15190 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15194 char *osalt_pos
= strchr (saltSize_pos
, '*');
15196 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15198 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15200 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15204 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15206 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15208 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15210 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15212 encryptedVerifier_pos
++;
15214 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15216 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15218 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15220 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15222 encryptedVerifierHash_pos
++;
15224 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;
15226 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15228 const uint version
= atoi (version_pos
);
15230 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15232 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15234 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15236 const uint keySize
= atoi (keySize_pos
);
15238 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15240 office2007
->keySize
= keySize
;
15242 const uint saltSize
= atoi (saltSize_pos
);
15244 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15250 salt
->salt_len
= 16;
15251 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15253 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15254 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15255 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15256 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15262 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15263 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15264 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15265 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15267 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15268 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15269 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15270 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15271 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15277 digest
[0] = office2007
->encryptedVerifierHash
[0];
15278 digest
[1] = office2007
->encryptedVerifierHash
[1];
15279 digest
[2] = office2007
->encryptedVerifierHash
[2];
15280 digest
[3] = office2007
->encryptedVerifierHash
[3];
15282 return (PARSER_OK
);
15285 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15287 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15289 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15291 u32
*digest
= (u32
*) hash_buf
->digest
;
15293 salt_t
*salt
= hash_buf
->salt
;
15295 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15301 char *version_pos
= input_buf
+ 8 + 1;
15303 char *spinCount_pos
= strchr (version_pos
, '*');
15305 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 u32 version_len
= spinCount_pos
- version_pos
;
15309 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15313 char *keySize_pos
= strchr (spinCount_pos
, '*');
15315 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15317 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15319 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15323 char *saltSize_pos
= strchr (keySize_pos
, '*');
15325 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15327 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15329 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15333 char *osalt_pos
= strchr (saltSize_pos
, '*');
15335 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15337 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15339 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15343 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15345 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15347 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15349 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15351 encryptedVerifier_pos
++;
15353 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15355 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15357 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15359 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15361 encryptedVerifierHash_pos
++;
15363 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;
15365 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15367 const uint version
= atoi (version_pos
);
15369 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15371 const uint spinCount
= atoi (spinCount_pos
);
15373 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15375 const uint keySize
= atoi (keySize_pos
);
15377 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15379 const uint saltSize
= atoi (saltSize_pos
);
15381 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15387 salt
->salt_len
= 16;
15388 salt
->salt_iter
= spinCount
;
15390 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15391 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15392 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15393 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15399 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15400 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15401 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15402 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15404 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15405 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15406 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15407 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15408 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15409 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15410 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15411 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15417 digest
[0] = office2010
->encryptedVerifierHash
[0];
15418 digest
[1] = office2010
->encryptedVerifierHash
[1];
15419 digest
[2] = office2010
->encryptedVerifierHash
[2];
15420 digest
[3] = office2010
->encryptedVerifierHash
[3];
15422 return (PARSER_OK
);
15425 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15427 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15429 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15431 u32
*digest
= (u32
*) hash_buf
->digest
;
15433 salt_t
*salt
= hash_buf
->salt
;
15435 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15441 char *version_pos
= input_buf
+ 8 + 1;
15443 char *spinCount_pos
= strchr (version_pos
, '*');
15445 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15447 u32 version_len
= spinCount_pos
- version_pos
;
15449 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15453 char *keySize_pos
= strchr (spinCount_pos
, '*');
15455 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15457 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15459 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15463 char *saltSize_pos
= strchr (keySize_pos
, '*');
15465 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15467 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15469 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15473 char *osalt_pos
= strchr (saltSize_pos
, '*');
15475 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15477 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15479 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15483 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15485 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15487 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15489 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15491 encryptedVerifier_pos
++;
15493 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15495 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15497 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15499 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15501 encryptedVerifierHash_pos
++;
15503 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;
15505 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15507 const uint version
= atoi (version_pos
);
15509 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15511 const uint spinCount
= atoi (spinCount_pos
);
15513 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15515 const uint keySize
= atoi (keySize_pos
);
15517 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15519 const uint saltSize
= atoi (saltSize_pos
);
15521 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15527 salt
->salt_len
= 16;
15528 salt
->salt_iter
= spinCount
;
15530 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15531 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15532 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15533 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15539 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15540 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15541 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15542 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15544 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15545 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15546 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15547 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15548 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15549 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15550 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15551 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15557 digest
[0] = office2013
->encryptedVerifierHash
[0];
15558 digest
[1] = office2013
->encryptedVerifierHash
[1];
15559 digest
[2] = office2013
->encryptedVerifierHash
[2];
15560 digest
[3] = office2013
->encryptedVerifierHash
[3];
15562 return (PARSER_OK
);
15565 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15567 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15569 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15571 u32
*digest
= (u32
*) hash_buf
->digest
;
15573 salt_t
*salt
= hash_buf
->salt
;
15575 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15581 char *version_pos
= input_buf
+ 11;
15583 char *osalt_pos
= strchr (version_pos
, '*');
15585 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15587 u32 version_len
= osalt_pos
- version_pos
;
15589 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15593 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15595 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15597 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15599 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15601 encryptedVerifier_pos
++;
15603 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15605 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15607 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15609 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15611 encryptedVerifierHash_pos
++;
15613 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15615 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15617 const uint version
= *version_pos
- 0x30;
15619 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15625 oldoffice01
->version
= version
;
15627 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15628 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15629 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15630 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15632 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15633 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15634 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15635 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15637 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15638 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15639 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15640 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15642 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15643 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15644 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15645 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15651 salt
->salt_len
= 16;
15653 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15654 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15655 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15656 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15658 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15659 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15660 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15661 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15663 // this is a workaround as office produces multiple documents with the same salt
15665 salt
->salt_len
+= 32;
15667 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15668 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15669 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15670 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15671 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15672 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15673 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15674 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15680 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15681 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15682 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15683 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15685 return (PARSER_OK
);
15688 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15690 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15693 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15695 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15697 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15699 u32
*digest
= (u32
*) hash_buf
->digest
;
15701 salt_t
*salt
= hash_buf
->salt
;
15703 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15709 char *version_pos
= input_buf
+ 11;
15711 char *osalt_pos
= strchr (version_pos
, '*');
15713 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15715 u32 version_len
= osalt_pos
- version_pos
;
15717 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15721 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15723 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15725 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15727 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15729 encryptedVerifier_pos
++;
15731 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15733 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15735 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15737 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15739 encryptedVerifierHash_pos
++;
15741 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15743 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15745 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15747 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15751 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15753 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15755 const uint version
= *version_pos
- 0x30;
15757 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15763 oldoffice01
->version
= version
;
15765 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15766 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15767 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15768 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15770 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15771 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15772 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15773 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15775 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15776 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15777 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15778 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15780 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15781 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15782 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15783 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15785 oldoffice01
->rc4key
[1] = 0;
15786 oldoffice01
->rc4key
[0] = 0;
15788 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15789 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15790 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15791 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15792 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15793 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15794 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15795 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15796 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15797 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15799 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15800 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15806 salt
->salt_len
= 16;
15808 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15809 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15810 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15811 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15813 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15814 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15815 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15816 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15818 // this is a workaround as office produces multiple documents with the same salt
15820 salt
->salt_len
+= 32;
15822 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15823 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15824 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15825 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15826 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15827 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15828 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15829 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15835 digest
[0] = oldoffice01
->rc4key
[0];
15836 digest
[1] = oldoffice01
->rc4key
[1];
15840 return (PARSER_OK
);
15843 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15845 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15847 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15849 u32
*digest
= (u32
*) hash_buf
->digest
;
15851 salt_t
*salt
= hash_buf
->salt
;
15853 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15859 char *version_pos
= input_buf
+ 11;
15861 char *osalt_pos
= strchr (version_pos
, '*');
15863 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15865 u32 version_len
= osalt_pos
- version_pos
;
15867 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15871 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15873 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15875 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15877 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15879 encryptedVerifier_pos
++;
15881 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15883 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15885 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15887 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15889 encryptedVerifierHash_pos
++;
15891 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15893 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15895 const uint version
= *version_pos
- 0x30;
15897 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15903 oldoffice34
->version
= version
;
15905 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15906 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15907 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15908 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15910 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15911 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15912 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15913 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15915 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15916 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15917 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15918 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15919 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15921 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15922 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15923 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15924 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15925 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15931 salt
->salt_len
= 16;
15933 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15934 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15935 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15936 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15938 // this is a workaround as office produces multiple documents with the same salt
15940 salt
->salt_len
+= 32;
15942 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15943 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15944 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15945 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15946 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15947 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15948 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15949 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15955 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15956 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15957 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15958 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15960 return (PARSER_OK
);
15963 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15965 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15967 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15970 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15972 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15974 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15976 u32
*digest
= (u32
*) hash_buf
->digest
;
15978 salt_t
*salt
= hash_buf
->salt
;
15980 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15986 char *version_pos
= input_buf
+ 11;
15988 char *osalt_pos
= strchr (version_pos
, '*');
15990 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15992 u32 version_len
= osalt_pos
- version_pos
;
15994 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15998 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16000 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16002 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16004 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16006 encryptedVerifier_pos
++;
16008 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16010 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16012 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16014 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16016 encryptedVerifierHash_pos
++;
16018 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16020 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16022 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16024 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16028 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16030 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16032 const uint version
= *version_pos
- 0x30;
16034 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16040 oldoffice34
->version
= version
;
16042 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16043 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16044 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16045 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16047 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16048 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16049 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16050 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16052 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16053 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16054 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16055 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16056 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16058 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16059 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16060 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16061 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16062 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16064 oldoffice34
->rc4key
[1] = 0;
16065 oldoffice34
->rc4key
[0] = 0;
16067 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16068 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16069 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16070 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16071 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16072 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16073 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16074 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16075 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16076 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16078 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16079 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16085 salt
->salt_len
= 16;
16087 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16088 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16089 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16090 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16092 // this is a workaround as office produces multiple documents with the same salt
16094 salt
->salt_len
+= 32;
16096 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16097 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16098 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16099 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16100 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16101 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16102 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16103 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16109 digest
[0] = oldoffice34
->rc4key
[0];
16110 digest
[1] = oldoffice34
->rc4key
[1];
16114 return (PARSER_OK
);
16117 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16119 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16121 u32
*digest
= (u32
*) hash_buf
->digest
;
16123 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16124 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16125 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16126 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16128 digest
[0] = byte_swap_32 (digest
[0]);
16129 digest
[1] = byte_swap_32 (digest
[1]);
16130 digest
[2] = byte_swap_32 (digest
[2]);
16131 digest
[3] = byte_swap_32 (digest
[3]);
16133 return (PARSER_OK
);
16136 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16138 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16140 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16142 u32
*digest
= (u32
*) hash_buf
->digest
;
16144 salt_t
*salt
= hash_buf
->salt
;
16146 char *signature_pos
= input_buf
;
16148 char *salt_pos
= strchr (signature_pos
, '$');
16150 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16152 u32 signature_len
= salt_pos
- signature_pos
;
16154 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16158 char *hash_pos
= strchr (salt_pos
, '$');
16160 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16162 u32 salt_len
= hash_pos
- salt_pos
;
16164 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16168 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16170 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16172 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16173 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16174 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16175 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16176 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16178 digest
[0] -= SHA1M_A
;
16179 digest
[1] -= SHA1M_B
;
16180 digest
[2] -= SHA1M_C
;
16181 digest
[3] -= SHA1M_D
;
16182 digest
[4] -= SHA1M_E
;
16184 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16186 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16188 salt
->salt_len
= salt_len
;
16190 return (PARSER_OK
);
16193 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16195 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16197 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16199 u32
*digest
= (u32
*) hash_buf
->digest
;
16201 salt_t
*salt
= hash_buf
->salt
;
16203 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16209 char *iter_pos
= input_buf
+ 14;
16211 const int iter
= atoi (iter_pos
);
16213 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16215 salt
->salt_iter
= iter
- 1;
16217 char *salt_pos
= strchr (iter_pos
, '$');
16219 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16223 char *hash_pos
= strchr (salt_pos
, '$');
16225 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16227 const uint salt_len
= hash_pos
- salt_pos
;
16231 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16233 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16235 salt
->salt_len
= salt_len
;
16237 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16238 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16240 // add some stuff to normal salt to make sorted happy
16242 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16243 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16244 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16245 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16246 salt
->salt_buf
[4] = salt
->salt_iter
;
16248 // base64 decode hash
16250 u8 tmp_buf
[100] = { 0 };
16252 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16254 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16256 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16258 memcpy (digest
, tmp_buf
, 32);
16260 digest
[0] = byte_swap_32 (digest
[0]);
16261 digest
[1] = byte_swap_32 (digest
[1]);
16262 digest
[2] = byte_swap_32 (digest
[2]);
16263 digest
[3] = byte_swap_32 (digest
[3]);
16264 digest
[4] = byte_swap_32 (digest
[4]);
16265 digest
[5] = byte_swap_32 (digest
[5]);
16266 digest
[6] = byte_swap_32 (digest
[6]);
16267 digest
[7] = byte_swap_32 (digest
[7]);
16269 return (PARSER_OK
);
16272 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16274 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16276 u32
*digest
= (u32
*) hash_buf
->digest
;
16278 salt_t
*salt
= hash_buf
->salt
;
16280 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16281 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16285 digest
[0] = byte_swap_32 (digest
[0]);
16286 digest
[1] = byte_swap_32 (digest
[1]);
16288 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16289 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16290 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16292 char iter_c
= input_buf
[17];
16293 char iter_d
= input_buf
[19];
16295 // atm only defaults, let's see if there's more request
16296 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16297 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16299 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16301 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16302 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16303 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16304 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16306 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16307 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16308 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16309 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16311 salt
->salt_len
= 16;
16313 return (PARSER_OK
);
16316 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16318 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16320 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16322 u32
*digest
= (u32
*) hash_buf
->digest
;
16324 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16326 salt_t
*salt
= hash_buf
->salt
;
16328 char *salt_pos
= input_buf
+ 10;
16330 char *hash_pos
= strchr (salt_pos
, '$');
16332 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 uint salt_len
= hash_pos
- salt_pos
;
16338 uint hash_len
= input_len
- 10 - salt_len
- 1;
16340 // base64 decode salt
16342 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16344 u8 tmp_buf
[100] = { 0 };
16346 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16348 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16350 tmp_buf
[salt_len
] = 0x80;
16352 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16354 salt
->salt_len
= salt_len
;
16356 // base64 decode hash
16358 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16360 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16362 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16364 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16366 uint user_len
= hash_len
- 32;
16368 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16370 user_len
--; // skip the trailing space
16372 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16373 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16374 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16375 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16377 digest
[0] = byte_swap_32 (digest
[0]);
16378 digest
[1] = byte_swap_32 (digest
[1]);
16379 digest
[2] = byte_swap_32 (digest
[2]);
16380 digest
[3] = byte_swap_32 (digest
[3]);
16382 // store username for host only (output hash if cracked)
16384 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16385 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16387 return (PARSER_OK
);
16390 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16392 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16394 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16396 u32
*digest
= (u32
*) hash_buf
->digest
;
16398 salt_t
*salt
= hash_buf
->salt
;
16400 char *iter_pos
= input_buf
+ 10;
16402 u32 iter
= atoi (iter_pos
);
16406 return (PARSER_SALT_ITERATION
);
16409 iter
--; // first iteration is special
16411 salt
->salt_iter
= iter
;
16413 char *base64_pos
= strchr (iter_pos
, '}');
16415 if (base64_pos
== NULL
)
16417 return (PARSER_SIGNATURE_UNMATCHED
);
16422 // base64 decode salt
16424 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16426 u8 tmp_buf
[100] = { 0 };
16428 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16430 if (decoded_len
< 24)
16432 return (PARSER_SALT_LENGTH
);
16437 uint salt_len
= decoded_len
- 20;
16439 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16440 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16442 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16444 salt
->salt_len
= salt_len
;
16448 u32
*digest_ptr
= (u32
*) tmp_buf
;
16450 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16451 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16452 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16453 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16454 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16456 return (PARSER_OK
);
16459 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16461 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16463 u32
*digest
= (u32
*) hash_buf
->digest
;
16465 salt_t
*salt
= hash_buf
->salt
;
16467 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16468 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16469 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16470 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16471 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16473 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16475 uint salt_len
= input_len
- 40 - 1;
16477 char *salt_buf
= input_buf
+ 40 + 1;
16479 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16481 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16483 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16485 salt
->salt_len
= salt_len
;
16487 return (PARSER_OK
);
16490 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16492 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16494 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16496 u32
*digest
= (u32
*) hash_buf
->digest
;
16498 salt_t
*salt
= hash_buf
->salt
;
16500 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16506 char *V_pos
= input_buf
+ 5;
16508 char *R_pos
= strchr (V_pos
, '*');
16510 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16512 u32 V_len
= R_pos
- V_pos
;
16516 char *bits_pos
= strchr (R_pos
, '*');
16518 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16520 u32 R_len
= bits_pos
- R_pos
;
16524 char *P_pos
= strchr (bits_pos
, '*');
16526 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16528 u32 bits_len
= P_pos
- bits_pos
;
16532 char *enc_md_pos
= strchr (P_pos
, '*');
16534 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16536 u32 P_len
= enc_md_pos
- P_pos
;
16540 char *id_len_pos
= strchr (enc_md_pos
, '*');
16542 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16544 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16548 char *id_buf_pos
= strchr (id_len_pos
, '*');
16550 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16552 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16556 char *u_len_pos
= strchr (id_buf_pos
, '*');
16558 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16560 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16562 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16566 char *u_buf_pos
= strchr (u_len_pos
, '*');
16568 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16570 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16574 char *o_len_pos
= strchr (u_buf_pos
, '*');
16576 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16578 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16580 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16584 char *o_buf_pos
= strchr (o_len_pos
, '*');
16586 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16588 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16592 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;
16594 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16598 const int V
= atoi (V_pos
);
16599 const int R
= atoi (R_pos
);
16600 const int P
= atoi (P_pos
);
16602 if (V
!= 1) return (PARSER_SALT_VALUE
);
16603 if (R
!= 2) return (PARSER_SALT_VALUE
);
16605 const int enc_md
= atoi (enc_md_pos
);
16607 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16609 const int id_len
= atoi (id_len_pos
);
16610 const int u_len
= atoi (u_len_pos
);
16611 const int o_len
= atoi (o_len_pos
);
16613 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16614 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16615 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16617 const int bits
= atoi (bits_pos
);
16619 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16621 // copy data to esalt
16627 pdf
->enc_md
= enc_md
;
16629 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16630 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16631 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16632 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16633 pdf
->id_len
= id_len
;
16635 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16636 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16637 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16638 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16639 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16640 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16641 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16642 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16643 pdf
->u_len
= u_len
;
16645 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16646 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16647 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16648 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16649 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16650 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16651 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16652 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16653 pdf
->o_len
= o_len
;
16655 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16656 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16657 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16658 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16660 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16661 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16662 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16663 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16664 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16665 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16666 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16667 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16669 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16670 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16671 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16672 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16673 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16674 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16675 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16676 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16678 // we use ID for salt, maybe needs to change, we will see...
16680 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16681 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16682 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16683 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16684 salt
->salt_len
= pdf
->id_len
;
16686 digest
[0] = pdf
->u_buf
[0];
16687 digest
[1] = pdf
->u_buf
[1];
16688 digest
[2] = pdf
->u_buf
[2];
16689 digest
[3] = pdf
->u_buf
[3];
16691 return (PARSER_OK
);
16694 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16696 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16699 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16701 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16703 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16705 u32
*digest
= (u32
*) hash_buf
->digest
;
16707 salt_t
*salt
= hash_buf
->salt
;
16709 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16715 char *V_pos
= input_buf
+ 5;
16717 char *R_pos
= strchr (V_pos
, '*');
16719 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16721 u32 V_len
= R_pos
- V_pos
;
16725 char *bits_pos
= strchr (R_pos
, '*');
16727 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16729 u32 R_len
= bits_pos
- R_pos
;
16733 char *P_pos
= strchr (bits_pos
, '*');
16735 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16737 u32 bits_len
= P_pos
- bits_pos
;
16741 char *enc_md_pos
= strchr (P_pos
, '*');
16743 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16745 u32 P_len
= enc_md_pos
- P_pos
;
16749 char *id_len_pos
= strchr (enc_md_pos
, '*');
16751 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16753 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16757 char *id_buf_pos
= strchr (id_len_pos
, '*');
16759 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16761 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16765 char *u_len_pos
= strchr (id_buf_pos
, '*');
16767 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16769 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16771 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16775 char *u_buf_pos
= strchr (u_len_pos
, '*');
16777 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16779 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16783 char *o_len_pos
= strchr (u_buf_pos
, '*');
16785 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16787 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16789 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16793 char *o_buf_pos
= strchr (o_len_pos
, '*');
16795 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16797 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16801 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16803 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16805 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16807 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16811 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;
16813 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16817 const int V
= atoi (V_pos
);
16818 const int R
= atoi (R_pos
);
16819 const int P
= atoi (P_pos
);
16821 if (V
!= 1) return (PARSER_SALT_VALUE
);
16822 if (R
!= 2) return (PARSER_SALT_VALUE
);
16824 const int enc_md
= atoi (enc_md_pos
);
16826 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16828 const int id_len
= atoi (id_len_pos
);
16829 const int u_len
= atoi (u_len_pos
);
16830 const int o_len
= atoi (o_len_pos
);
16832 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16833 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16834 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16836 const int bits
= atoi (bits_pos
);
16838 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16840 // copy data to esalt
16846 pdf
->enc_md
= enc_md
;
16848 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16849 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16850 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16851 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16852 pdf
->id_len
= id_len
;
16854 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16855 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16856 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16857 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16858 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16859 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16860 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16861 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16862 pdf
->u_len
= u_len
;
16864 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16865 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16866 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16867 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16868 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16869 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16870 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16871 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16872 pdf
->o_len
= o_len
;
16874 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16875 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16876 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16877 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16879 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16880 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16881 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16882 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16883 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16884 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16885 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16886 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16888 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16889 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16890 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16891 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16892 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16893 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16894 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16895 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16897 pdf
->rc4key
[1] = 0;
16898 pdf
->rc4key
[0] = 0;
16900 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16901 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16902 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16903 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16904 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16905 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16906 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16907 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16908 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16909 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16911 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16912 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16914 // we use ID for salt, maybe needs to change, we will see...
16916 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16917 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16918 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16919 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16920 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16921 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16922 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16923 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16924 salt
->salt_len
= pdf
->id_len
+ 16;
16926 digest
[0] = pdf
->rc4key
[0];
16927 digest
[1] = pdf
->rc4key
[1];
16931 return (PARSER_OK
);
16934 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16936 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16938 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16940 u32
*digest
= (u32
*) hash_buf
->digest
;
16942 salt_t
*salt
= hash_buf
->salt
;
16944 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16950 char *V_pos
= input_buf
+ 5;
16952 char *R_pos
= strchr (V_pos
, '*');
16954 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16956 u32 V_len
= R_pos
- V_pos
;
16960 char *bits_pos
= strchr (R_pos
, '*');
16962 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16964 u32 R_len
= bits_pos
- R_pos
;
16968 char *P_pos
= strchr (bits_pos
, '*');
16970 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16972 u32 bits_len
= P_pos
- bits_pos
;
16976 char *enc_md_pos
= strchr (P_pos
, '*');
16978 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16980 u32 P_len
= enc_md_pos
- P_pos
;
16984 char *id_len_pos
= strchr (enc_md_pos
, '*');
16986 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16988 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16992 char *id_buf_pos
= strchr (id_len_pos
, '*');
16994 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16996 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17000 char *u_len_pos
= strchr (id_buf_pos
, '*');
17002 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17004 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17006 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17010 char *u_buf_pos
= strchr (u_len_pos
, '*');
17012 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17014 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17018 char *o_len_pos
= strchr (u_buf_pos
, '*');
17020 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17022 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17024 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17028 char *o_buf_pos
= strchr (o_len_pos
, '*');
17030 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17032 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17036 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;
17038 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17042 const int V
= atoi (V_pos
);
17043 const int R
= atoi (R_pos
);
17044 const int P
= atoi (P_pos
);
17048 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17049 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17051 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17053 const int id_len
= atoi (id_len_pos
);
17054 const int u_len
= atoi (u_len_pos
);
17055 const int o_len
= atoi (o_len_pos
);
17057 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17059 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17060 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17062 const int bits
= atoi (bits_pos
);
17064 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17070 enc_md
= atoi (enc_md_pos
);
17073 // copy data to esalt
17079 pdf
->enc_md
= enc_md
;
17081 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17082 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17083 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17084 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17088 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17089 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17090 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17091 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17094 pdf
->id_len
= id_len
;
17096 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17097 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17098 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17099 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17100 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17101 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17102 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17103 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17104 pdf
->u_len
= u_len
;
17106 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17107 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17108 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17109 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17110 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17111 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17112 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17113 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17114 pdf
->o_len
= o_len
;
17116 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17117 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17118 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17119 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17123 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17124 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17125 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17126 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17129 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17130 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17131 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17132 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17133 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17134 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17135 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17136 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17138 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17139 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17140 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17141 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17142 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17143 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17144 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17145 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17147 // precompute rc4 data for later use
17163 uint salt_pc_block
[32] = { 0 };
17165 char *salt_pc_ptr
= (char *) salt_pc_block
;
17167 memcpy (salt_pc_ptr
, padding
, 32);
17168 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17170 uint salt_pc_digest
[4] = { 0 };
17172 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17174 pdf
->rc4data
[0] = salt_pc_digest
[0];
17175 pdf
->rc4data
[1] = salt_pc_digest
[1];
17177 // we use ID for salt, maybe needs to change, we will see...
17179 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17180 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17181 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17182 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17183 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17184 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17185 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17186 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17187 salt
->salt_len
= pdf
->id_len
+ 16;
17189 salt
->salt_iter
= ROUNDS_PDF14
;
17191 digest
[0] = pdf
->u_buf
[0];
17192 digest
[1] = pdf
->u_buf
[1];
17196 return (PARSER_OK
);
17199 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17201 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17203 if (ret
!= PARSER_OK
)
17208 u32
*digest
= (u32
*) hash_buf
->digest
;
17210 salt_t
*salt
= hash_buf
->salt
;
17212 digest
[0] -= SHA256M_A
;
17213 digest
[1] -= SHA256M_B
;
17214 digest
[2] -= SHA256M_C
;
17215 digest
[3] -= SHA256M_D
;
17216 digest
[4] -= SHA256M_E
;
17217 digest
[5] -= SHA256M_F
;
17218 digest
[6] -= SHA256M_G
;
17219 digest
[7] -= SHA256M_H
;
17221 salt
->salt_buf
[2] = 0x80;
17223 return (PARSER_OK
);
17226 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17228 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17230 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17232 u32
*digest
= (u32
*) hash_buf
->digest
;
17234 salt_t
*salt
= hash_buf
->salt
;
17236 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17242 char *V_pos
= input_buf
+ 5;
17244 char *R_pos
= strchr (V_pos
, '*');
17246 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17248 u32 V_len
= R_pos
- V_pos
;
17252 char *bits_pos
= strchr (R_pos
, '*');
17254 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17256 u32 R_len
= bits_pos
- R_pos
;
17260 char *P_pos
= strchr (bits_pos
, '*');
17262 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17264 u32 bits_len
= P_pos
- bits_pos
;
17268 char *enc_md_pos
= strchr (P_pos
, '*');
17270 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17272 u32 P_len
= enc_md_pos
- P_pos
;
17276 char *id_len_pos
= strchr (enc_md_pos
, '*');
17278 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17280 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17284 char *id_buf_pos
= strchr (id_len_pos
, '*');
17286 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17288 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17292 char *u_len_pos
= strchr (id_buf_pos
, '*');
17294 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17296 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17300 char *u_buf_pos
= strchr (u_len_pos
, '*');
17302 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17308 char *o_len_pos
= strchr (u_buf_pos
, '*');
17310 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17312 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17316 char *o_buf_pos
= strchr (o_len_pos
, '*');
17318 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17324 char *last
= strchr (o_buf_pos
, '*');
17326 if (last
== NULL
) last
= input_buf
+ input_len
;
17328 u32 o_buf_len
= last
- o_buf_pos
;
17332 const int V
= atoi (V_pos
);
17333 const int R
= atoi (R_pos
);
17337 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17338 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17340 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17342 const int bits
= atoi (bits_pos
);
17344 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17346 int enc_md
= atoi (enc_md_pos
);
17348 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17350 const uint id_len
= atoi (id_len_pos
);
17351 const uint u_len
= atoi (u_len_pos
);
17352 const uint o_len
= atoi (o_len_pos
);
17354 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17355 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17356 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17357 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17358 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17359 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17360 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17361 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17363 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17364 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17365 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17367 // copy data to esalt
17369 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17371 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17373 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17376 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17377 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17379 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17380 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17382 salt
->salt_len
= 8;
17383 salt
->salt_iter
= ROUNDS_PDF17L8
;
17385 digest
[0] = pdf
->u_buf
[0];
17386 digest
[1] = pdf
->u_buf
[1];
17387 digest
[2] = pdf
->u_buf
[2];
17388 digest
[3] = pdf
->u_buf
[3];
17389 digest
[4] = pdf
->u_buf
[4];
17390 digest
[5] = pdf
->u_buf
[5];
17391 digest
[6] = pdf
->u_buf
[6];
17392 digest
[7] = pdf
->u_buf
[7];
17394 return (PARSER_OK
);
17397 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17399 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17401 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17403 u32
*digest
= (u32
*) hash_buf
->digest
;
17405 salt_t
*salt
= hash_buf
->salt
;
17407 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17415 char *iter_pos
= input_buf
+ 7;
17417 u32 iter
= atoi (iter_pos
);
17419 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17420 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17422 // first is *raw* salt
17424 char *salt_pos
= strchr (iter_pos
, ':');
17426 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17430 char *hash_pos
= strchr (salt_pos
, ':');
17432 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17434 u32 salt_len
= hash_pos
- salt_pos
;
17436 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17440 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17442 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17446 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17448 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17450 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17452 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17453 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17455 salt
->salt_len
= salt_len
;
17456 salt
->salt_iter
= iter
- 1;
17460 u8 tmp_buf
[100] = { 0 };
17462 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17464 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17466 memcpy (digest
, tmp_buf
, 16);
17468 digest
[0] = byte_swap_32 (digest
[0]);
17469 digest
[1] = byte_swap_32 (digest
[1]);
17470 digest
[2] = byte_swap_32 (digest
[2]);
17471 digest
[3] = byte_swap_32 (digest
[3]);
17473 // add some stuff to normal salt to make sorted happy
17475 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17476 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17477 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17478 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17479 salt
->salt_buf
[4] = salt
->salt_iter
;
17481 return (PARSER_OK
);
17484 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17486 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17488 u32
*digest
= (u32
*) hash_buf
->digest
;
17490 salt_t
*salt
= hash_buf
->salt
;
17492 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17493 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17494 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17495 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17497 digest
[0] = byte_swap_32 (digest
[0]);
17498 digest
[1] = byte_swap_32 (digest
[1]);
17499 digest
[2] = byte_swap_32 (digest
[2]);
17500 digest
[3] = byte_swap_32 (digest
[3]);
17502 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17504 uint salt_len
= input_len
- 32 - 1;
17506 char *salt_buf
= input_buf
+ 32 + 1;
17508 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17510 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17512 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17514 salt
->salt_len
= salt_len
;
17516 return (PARSER_OK
);
17519 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17521 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17523 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17525 u32
*digest
= (u32
*) hash_buf
->digest
;
17527 salt_t
*salt
= hash_buf
->salt
;
17529 char *user_pos
= input_buf
+ 10;
17531 char *salt_pos
= strchr (user_pos
, '*');
17533 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17537 char *hash_pos
= strchr (salt_pos
, '*');
17541 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17543 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17545 uint user_len
= salt_pos
- user_pos
- 1;
17547 uint salt_len
= hash_pos
- salt_pos
- 1;
17549 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17555 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17556 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17557 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17558 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17560 digest
[0] = byte_swap_32 (digest
[0]);
17561 digest
[1] = byte_swap_32 (digest
[1]);
17562 digest
[2] = byte_swap_32 (digest
[2]);
17563 digest
[3] = byte_swap_32 (digest
[3]);
17565 digest
[0] -= MD5M_A
;
17566 digest
[1] -= MD5M_B
;
17567 digest
[2] -= MD5M_C
;
17568 digest
[3] -= MD5M_D
;
17574 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17576 // first 4 bytes are the "challenge"
17578 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17579 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17580 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17581 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17583 // append the user name
17585 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17587 salt
->salt_len
= 4 + user_len
;
17589 return (PARSER_OK
);
17592 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17594 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17596 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17598 u32
*digest
= (u32
*) hash_buf
->digest
;
17600 salt_t
*salt
= hash_buf
->salt
;
17602 char *salt_pos
= input_buf
+ 9;
17604 char *hash_pos
= strchr (salt_pos
, '*');
17606 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17610 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17612 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17614 uint salt_len
= hash_pos
- salt_pos
- 1;
17616 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17622 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17623 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17624 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17625 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17626 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17634 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17636 salt
->salt_len
= salt_len
;
17638 return (PARSER_OK
);
17641 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17643 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17645 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17647 u32
*digest
= (u32
*) hash_buf
->digest
;
17649 salt_t
*salt
= hash_buf
->salt
;
17651 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17657 char *cry_master_len_pos
= input_buf
+ 9;
17659 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17661 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17663 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17665 cry_master_buf_pos
++;
17667 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17669 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17671 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17673 cry_salt_len_pos
++;
17675 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17677 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17679 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17681 cry_salt_buf_pos
++;
17683 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17685 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17687 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17691 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17693 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17695 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17699 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17701 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17703 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17707 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17709 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17711 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17713 public_key_len_pos
++;
17715 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17717 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17719 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17721 public_key_buf_pos
++;
17723 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;
17725 const uint cry_master_len
= atoi (cry_master_len_pos
);
17726 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17727 const uint ckey_len
= atoi (ckey_len_pos
);
17728 const uint public_key_len
= atoi (public_key_len_pos
);
17730 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17731 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17732 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17733 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17735 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17737 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17739 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17742 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17744 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17746 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17749 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17751 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17753 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17756 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17757 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17758 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17761 * store digest (should be unique enought, hopefully)
17764 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17765 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17766 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17767 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17773 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17775 const uint cry_rounds
= atoi (cry_rounds_pos
);
17777 salt
->salt_iter
= cry_rounds
- 1;
17779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17781 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17783 salt
->salt_len
= salt_len
;
17785 return (PARSER_OK
);
17788 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17790 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17792 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17794 u32
*digest
= (u32
*) hash_buf
->digest
;
17796 salt_t
*salt
= hash_buf
->salt
;
17798 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17800 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17802 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17804 memcpy (temp_input_buf
, input_buf
, input_len
);
17808 char *URI_server_pos
= temp_input_buf
+ 6;
17810 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17812 if (URI_client_pos
== NULL
)
17814 myfree (temp_input_buf
);
17816 return (PARSER_SEPARATOR_UNMATCHED
);
17819 URI_client_pos
[0] = 0;
17822 uint URI_server_len
= strlen (URI_server_pos
);
17824 if (URI_server_len
> 512)
17826 myfree (temp_input_buf
);
17828 return (PARSER_SALT_LENGTH
);
17833 char *user_pos
= strchr (URI_client_pos
, '*');
17835 if (user_pos
== NULL
)
17837 myfree (temp_input_buf
);
17839 return (PARSER_SEPARATOR_UNMATCHED
);
17845 uint URI_client_len
= strlen (URI_client_pos
);
17847 if (URI_client_len
> 512)
17849 myfree (temp_input_buf
);
17851 return (PARSER_SALT_LENGTH
);
17856 char *realm_pos
= strchr (user_pos
, '*');
17858 if (realm_pos
== NULL
)
17860 myfree (temp_input_buf
);
17862 return (PARSER_SEPARATOR_UNMATCHED
);
17868 uint user_len
= strlen (user_pos
);
17870 if (user_len
> 116)
17872 myfree (temp_input_buf
);
17874 return (PARSER_SALT_LENGTH
);
17879 char *method_pos
= strchr (realm_pos
, '*');
17881 if (method_pos
== NULL
)
17883 myfree (temp_input_buf
);
17885 return (PARSER_SEPARATOR_UNMATCHED
);
17891 uint realm_len
= strlen (realm_pos
);
17893 if (realm_len
> 116)
17895 myfree (temp_input_buf
);
17897 return (PARSER_SALT_LENGTH
);
17902 char *URI_prefix_pos
= strchr (method_pos
, '*');
17904 if (URI_prefix_pos
== NULL
)
17906 myfree (temp_input_buf
);
17908 return (PARSER_SEPARATOR_UNMATCHED
);
17911 URI_prefix_pos
[0] = 0;
17914 uint method_len
= strlen (method_pos
);
17916 if (method_len
> 246)
17918 myfree (temp_input_buf
);
17920 return (PARSER_SALT_LENGTH
);
17925 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17927 if (URI_resource_pos
== NULL
)
17929 myfree (temp_input_buf
);
17931 return (PARSER_SEPARATOR_UNMATCHED
);
17934 URI_resource_pos
[0] = 0;
17935 URI_resource_pos
++;
17937 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17939 if (URI_prefix_len
> 245)
17941 myfree (temp_input_buf
);
17943 return (PARSER_SALT_LENGTH
);
17948 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17950 if (URI_suffix_pos
== NULL
)
17952 myfree (temp_input_buf
);
17954 return (PARSER_SEPARATOR_UNMATCHED
);
17957 URI_suffix_pos
[0] = 0;
17960 uint URI_resource_len
= strlen (URI_resource_pos
);
17962 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17964 myfree (temp_input_buf
);
17966 return (PARSER_SALT_LENGTH
);
17971 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17973 if (nonce_pos
== NULL
)
17975 myfree (temp_input_buf
);
17977 return (PARSER_SEPARATOR_UNMATCHED
);
17983 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17985 if (URI_suffix_len
> 245)
17987 myfree (temp_input_buf
);
17989 return (PARSER_SALT_LENGTH
);
17994 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17996 if (nonce_client_pos
== NULL
)
17998 myfree (temp_input_buf
);
18000 return (PARSER_SEPARATOR_UNMATCHED
);
18003 nonce_client_pos
[0] = 0;
18004 nonce_client_pos
++;
18006 uint nonce_len
= strlen (nonce_pos
);
18008 if (nonce_len
< 1 || nonce_len
> 50)
18010 myfree (temp_input_buf
);
18012 return (PARSER_SALT_LENGTH
);
18017 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18019 if (nonce_count_pos
== NULL
)
18021 myfree (temp_input_buf
);
18023 return (PARSER_SEPARATOR_UNMATCHED
);
18026 nonce_count_pos
[0] = 0;
18029 uint nonce_client_len
= strlen (nonce_client_pos
);
18031 if (nonce_client_len
> 50)
18033 myfree (temp_input_buf
);
18035 return (PARSER_SALT_LENGTH
);
18040 char *qop_pos
= strchr (nonce_count_pos
, '*');
18042 if (qop_pos
== NULL
)
18044 myfree (temp_input_buf
);
18046 return (PARSER_SEPARATOR_UNMATCHED
);
18052 uint nonce_count_len
= strlen (nonce_count_pos
);
18054 if (nonce_count_len
> 50)
18056 myfree (temp_input_buf
);
18058 return (PARSER_SALT_LENGTH
);
18063 char *directive_pos
= strchr (qop_pos
, '*');
18065 if (directive_pos
== NULL
)
18067 myfree (temp_input_buf
);
18069 return (PARSER_SEPARATOR_UNMATCHED
);
18072 directive_pos
[0] = 0;
18075 uint qop_len
= strlen (qop_pos
);
18079 myfree (temp_input_buf
);
18081 return (PARSER_SALT_LENGTH
);
18086 char *digest_pos
= strchr (directive_pos
, '*');
18088 if (digest_pos
== NULL
)
18090 myfree (temp_input_buf
);
18092 return (PARSER_SEPARATOR_UNMATCHED
);
18098 uint directive_len
= strlen (directive_pos
);
18100 if (directive_len
!= 3)
18102 myfree (temp_input_buf
);
18104 return (PARSER_SALT_LENGTH
);
18107 if (memcmp (directive_pos
, "MD5", 3))
18109 log_info ("ERROR: only the MD5 directive is currently supported\n");
18111 myfree (temp_input_buf
);
18113 return (PARSER_SIP_AUTH_DIRECTIVE
);
18117 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18122 uint md5_max_len
= 4 * 64;
18124 uint md5_remaining_len
= md5_max_len
;
18126 uint tmp_md5_buf
[64] = { 0 };
18128 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18130 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18132 md5_len
+= method_len
+ 1;
18133 tmp_md5_ptr
+= method_len
+ 1;
18135 if (URI_prefix_len
> 0)
18137 md5_remaining_len
= md5_max_len
- md5_len
;
18139 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18141 md5_len
+= URI_prefix_len
+ 1;
18142 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18145 md5_remaining_len
= md5_max_len
- md5_len
;
18147 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18149 md5_len
+= URI_resource_len
;
18150 tmp_md5_ptr
+= URI_resource_len
;
18152 if (URI_suffix_len
> 0)
18154 md5_remaining_len
= md5_max_len
- md5_len
;
18156 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18158 md5_len
+= 1 + URI_suffix_len
;
18161 uint tmp_digest
[4] = { 0 };
18163 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18165 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18166 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18167 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18168 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18174 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18176 uint esalt_len
= 0;
18178 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18180 // there are 2 possibilities for the esalt:
18182 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18184 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18186 if (esalt_len
> max_esalt_len
)
18188 myfree (temp_input_buf
);
18190 return (PARSER_SALT_LENGTH
);
18193 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18205 esalt_len
= 1 + nonce_len
+ 1 + 32;
18207 if (esalt_len
> max_esalt_len
)
18209 myfree (temp_input_buf
);
18211 return (PARSER_SALT_LENGTH
);
18214 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18222 // add 0x80 to esalt
18224 esalt_buf_ptr
[esalt_len
] = 0x80;
18226 sip
->esalt_len
= esalt_len
;
18232 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18234 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18236 uint max_salt_len
= 119;
18238 if (salt_len
> max_salt_len
)
18240 myfree (temp_input_buf
);
18242 return (PARSER_SALT_LENGTH
);
18245 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18247 sip
->salt_len
= salt_len
;
18250 * fake salt (for sorting)
18253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18257 uint fake_salt_len
= salt_len
;
18259 if (fake_salt_len
> max_salt_len
)
18261 fake_salt_len
= max_salt_len
;
18264 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18266 salt
->salt_len
= fake_salt_len
;
18272 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18273 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18274 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18275 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18277 digest
[0] = byte_swap_32 (digest
[0]);
18278 digest
[1] = byte_swap_32 (digest
[1]);
18279 digest
[2] = byte_swap_32 (digest
[2]);
18280 digest
[3] = byte_swap_32 (digest
[3]);
18282 myfree (temp_input_buf
);
18284 return (PARSER_OK
);
18287 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18289 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18291 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18293 u32
*digest
= (u32
*) hash_buf
->digest
;
18295 salt_t
*salt
= hash_buf
->salt
;
18299 char *digest_pos
= input_buf
;
18301 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18308 char *salt_buf
= input_buf
+ 8 + 1;
18312 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18314 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18316 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18318 salt
->salt_len
= salt_len
;
18320 return (PARSER_OK
);
18323 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18325 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18327 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18329 u32
*digest
= (u32
*) hash_buf
->digest
;
18331 salt_t
*salt
= hash_buf
->salt
;
18333 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18339 char *p_buf_pos
= input_buf
+ 4;
18341 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18343 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18345 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18347 NumCyclesPower_pos
++;
18349 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18351 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18353 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18357 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18359 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18361 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18365 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18367 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18369 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18373 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18375 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18377 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18381 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18383 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18385 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18389 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18391 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18393 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18397 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18399 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18401 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18405 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18407 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18409 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18413 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;
18415 const uint iter
= atoi (NumCyclesPower_pos
);
18416 const uint crc
= atoi (crc_buf_pos
);
18417 const uint p_buf
= atoi (p_buf_pos
);
18418 const uint salt_len
= atoi (salt_len_pos
);
18419 const uint iv_len
= atoi (iv_len_pos
);
18420 const uint unpack_size
= atoi (unpack_size_pos
);
18421 const uint data_len
= atoi (data_len_pos
);
18427 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18428 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18430 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18432 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18434 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18440 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18441 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18442 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18443 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18445 seven_zip
->iv_len
= iv_len
;
18447 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18449 seven_zip
->salt_len
= 0;
18451 seven_zip
->crc
= crc
;
18453 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18455 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18457 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18460 seven_zip
->data_len
= data_len
;
18462 seven_zip
->unpack_size
= unpack_size
;
18466 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18467 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18468 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18469 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18471 salt
->salt_len
= 16;
18473 salt
->salt_sign
[0] = iter
;
18475 salt
->salt_iter
= 1 << iter
;
18486 return (PARSER_OK
);
18489 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18491 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18493 u32
*digest
= (u32
*) hash_buf
->digest
;
18495 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18496 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18497 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18498 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18499 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18500 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18501 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18502 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18504 digest
[0] = byte_swap_32 (digest
[0]);
18505 digest
[1] = byte_swap_32 (digest
[1]);
18506 digest
[2] = byte_swap_32 (digest
[2]);
18507 digest
[3] = byte_swap_32 (digest
[3]);
18508 digest
[4] = byte_swap_32 (digest
[4]);
18509 digest
[5] = byte_swap_32 (digest
[5]);
18510 digest
[6] = byte_swap_32 (digest
[6]);
18511 digest
[7] = byte_swap_32 (digest
[7]);
18513 return (PARSER_OK
);
18516 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18518 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18520 u32
*digest
= (u32
*) hash_buf
->digest
;
18522 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18523 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18524 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18525 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18526 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18527 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18528 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18529 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18530 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18531 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18532 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18533 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18534 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18535 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18536 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18537 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18539 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18540 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18541 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18542 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18543 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18544 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18545 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18546 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18547 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18548 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18549 digest
[10] = byte_swap_32 (digest
[10]);
18550 digest
[11] = byte_swap_32 (digest
[11]);
18551 digest
[12] = byte_swap_32 (digest
[12]);
18552 digest
[13] = byte_swap_32 (digest
[13]);
18553 digest
[14] = byte_swap_32 (digest
[14]);
18554 digest
[15] = byte_swap_32 (digest
[15]);
18556 return (PARSER_OK
);
18559 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18561 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18563 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18565 u32
*digest
= (u32
*) hash_buf
->digest
;
18567 salt_t
*salt
= hash_buf
->salt
;
18569 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18577 char *iter_pos
= input_buf
+ 4;
18579 u32 iter
= atoi (iter_pos
);
18581 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18582 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18584 // first is *raw* salt
18586 char *salt_pos
= strchr (iter_pos
, ':');
18588 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18592 char *hash_pos
= strchr (salt_pos
, ':');
18594 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18596 u32 salt_len
= hash_pos
- salt_pos
;
18598 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18602 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18604 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18608 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18610 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18612 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18614 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18615 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18617 salt
->salt_len
= salt_len
;
18618 salt
->salt_iter
= iter
- 1;
18622 u8 tmp_buf
[100] = { 0 };
18624 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18626 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18628 memcpy (digest
, tmp_buf
, 16);
18630 // add some stuff to normal salt to make sorted happy
18632 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18633 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18634 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18635 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18636 salt
->salt_buf
[4] = salt
->salt_iter
;
18638 return (PARSER_OK
);
18641 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18643 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18645 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18647 u32
*digest
= (u32
*) hash_buf
->digest
;
18649 salt_t
*salt
= hash_buf
->salt
;
18651 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18659 char *iter_pos
= input_buf
+ 5;
18661 u32 iter
= atoi (iter_pos
);
18663 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18664 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18666 // first is *raw* salt
18668 char *salt_pos
= strchr (iter_pos
, ':');
18670 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18674 char *hash_pos
= strchr (salt_pos
, ':');
18676 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18678 u32 salt_len
= hash_pos
- salt_pos
;
18680 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18684 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18686 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18690 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18692 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18694 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18696 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18697 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18699 salt
->salt_len
= salt_len
;
18700 salt
->salt_iter
= iter
- 1;
18704 u8 tmp_buf
[100] = { 0 };
18706 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18708 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18710 memcpy (digest
, tmp_buf
, 16);
18712 digest
[0] = byte_swap_32 (digest
[0]);
18713 digest
[1] = byte_swap_32 (digest
[1]);
18714 digest
[2] = byte_swap_32 (digest
[2]);
18715 digest
[3] = byte_swap_32 (digest
[3]);
18717 // add some stuff to normal salt to make sorted happy
18719 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18720 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18721 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18722 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18723 salt
->salt_buf
[4] = salt
->salt_iter
;
18725 return (PARSER_OK
);
18728 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18730 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18732 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18734 u64
*digest
= (u64
*) hash_buf
->digest
;
18736 salt_t
*salt
= hash_buf
->salt
;
18738 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18746 char *iter_pos
= input_buf
+ 7;
18748 u32 iter
= atoi (iter_pos
);
18750 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18751 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18753 // first is *raw* salt
18755 char *salt_pos
= strchr (iter_pos
, ':');
18757 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18761 char *hash_pos
= strchr (salt_pos
, ':');
18763 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18765 u32 salt_len
= hash_pos
- salt_pos
;
18767 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18771 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18773 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18777 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18779 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18781 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18783 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18784 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18786 salt
->salt_len
= salt_len
;
18787 salt
->salt_iter
= iter
- 1;
18791 u8 tmp_buf
[100] = { 0 };
18793 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18795 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18797 memcpy (digest
, tmp_buf
, 64);
18799 digest
[0] = byte_swap_64 (digest
[0]);
18800 digest
[1] = byte_swap_64 (digest
[1]);
18801 digest
[2] = byte_swap_64 (digest
[2]);
18802 digest
[3] = byte_swap_64 (digest
[3]);
18803 digest
[4] = byte_swap_64 (digest
[4]);
18804 digest
[5] = byte_swap_64 (digest
[5]);
18805 digest
[6] = byte_swap_64 (digest
[6]);
18806 digest
[7] = byte_swap_64 (digest
[7]);
18808 // add some stuff to normal salt to make sorted happy
18810 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18811 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18812 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18813 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18814 salt
->salt_buf
[4] = salt
->salt_iter
;
18816 return (PARSER_OK
);
18819 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18821 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18823 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18825 uint
*digest
= (uint
*) hash_buf
->digest
;
18827 salt_t
*salt
= hash_buf
->salt
;
18833 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18835 char *hash_pos
= strchr (salt_pos
, '$');
18837 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18839 u32 salt_len
= hash_pos
- salt_pos
;
18841 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18845 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18847 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18851 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18852 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18870 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18871 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18873 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18874 salt
->salt_len
= 8;
18876 return (PARSER_OK
);
18879 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18881 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18883 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18885 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18887 if (c19
& 3) return (PARSER_HASH_VALUE
);
18889 salt_t
*salt
= hash_buf
->salt
;
18891 u32
*digest
= (u32
*) hash_buf
->digest
;
18895 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18896 | itoa64_to_int (input_buf
[2]) << 6
18897 | itoa64_to_int (input_buf
[3]) << 12
18898 | itoa64_to_int (input_buf
[4]) << 18;
18902 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18903 | itoa64_to_int (input_buf
[6]) << 6
18904 | itoa64_to_int (input_buf
[7]) << 12
18905 | itoa64_to_int (input_buf
[8]) << 18;
18907 salt
->salt_len
= 4;
18909 u8 tmp_buf
[100] = { 0 };
18911 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18913 memcpy (digest
, tmp_buf
, 8);
18917 IP (digest
[0], digest
[1], tt
);
18919 digest
[0] = rotr32 (digest
[0], 31);
18920 digest
[1] = rotr32 (digest
[1], 31);
18924 return (PARSER_OK
);
18927 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18929 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18931 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18933 u32
*digest
= (u32
*) hash_buf
->digest
;
18935 salt_t
*salt
= hash_buf
->salt
;
18941 char *type_pos
= input_buf
+ 6 + 1;
18943 char *salt_pos
= strchr (type_pos
, '*');
18945 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18947 u32 type_len
= salt_pos
- type_pos
;
18949 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18953 char *crypted_pos
= strchr (salt_pos
, '*');
18955 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18957 u32 salt_len
= crypted_pos
- salt_pos
;
18959 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18963 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18965 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18971 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18972 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18974 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18975 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18977 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18978 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18979 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18980 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18982 salt
->salt_len
= 24;
18983 salt
->salt_iter
= ROUNDS_RAR3
;
18985 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18986 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18988 digest
[0] = 0xc43d7b00;
18989 digest
[1] = 0x40070000;
18993 return (PARSER_OK
);
18996 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18998 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19000 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19002 u32
*digest
= (u32
*) hash_buf
->digest
;
19004 salt_t
*salt
= hash_buf
->salt
;
19006 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19012 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19014 char *param1_pos
= strchr (param0_pos
, '$');
19016 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19018 u32 param0_len
= param1_pos
- param0_pos
;
19022 char *param2_pos
= strchr (param1_pos
, '$');
19024 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19026 u32 param1_len
= param2_pos
- param1_pos
;
19030 char *param3_pos
= strchr (param2_pos
, '$');
19032 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19034 u32 param2_len
= param3_pos
- param2_pos
;
19038 char *param4_pos
= strchr (param3_pos
, '$');
19040 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19042 u32 param3_len
= param4_pos
- param3_pos
;
19046 char *param5_pos
= strchr (param4_pos
, '$');
19048 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19050 u32 param4_len
= param5_pos
- param4_pos
;
19054 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19056 char *salt_buf
= param1_pos
;
19057 char *iv
= param3_pos
;
19058 char *pswcheck
= param5_pos
;
19060 const uint salt_len
= atoi (param0_pos
);
19061 const uint iterations
= atoi (param2_pos
);
19062 const uint pswcheck_len
= atoi (param4_pos
);
19068 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19069 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19070 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19072 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19073 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19074 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19080 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19081 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19082 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19083 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19085 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19086 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19087 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19088 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19090 salt
->salt_len
= 16;
19092 salt
->salt_sign
[0] = iterations
;
19094 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19100 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19101 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19105 return (PARSER_OK
);
19108 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19110 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19112 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19114 u32
*digest
= (u32
*) hash_buf
->digest
;
19116 salt_t
*salt
= hash_buf
->salt
;
19118 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19125 char *account_pos
= input_buf
+ 11 + 1;
19131 if (account_pos
[0] == '*')
19135 data_pos
= strchr (account_pos
, '*');
19140 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19142 uint account_len
= data_pos
- account_pos
+ 1;
19144 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19149 data_len
= input_len
- 11 - 1 - account_len
- 2;
19151 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19155 /* assume $krb5tgs$23$checksum$edata2 */
19156 data_pos
= account_pos
;
19158 memcpy (krb5tgs
->account_info
, "**", 3);
19160 data_len
= input_len
- 11 - 1 - 1;
19163 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19165 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19167 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19169 const char p0
= data_pos
[i
+ 0];
19170 const char p1
= data_pos
[i
+ 1];
19172 *checksum_ptr
++ = hex_convert (p1
) << 0
19173 | hex_convert (p0
) << 4;
19176 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19178 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19181 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19183 const char p0
= data_pos
[i
+ 0];
19184 const char p1
= data_pos
[i
+ 1];
19185 *edata_ptr
++ = hex_convert (p1
) << 0
19186 | hex_convert (p0
) << 4;
19189 /* this is needed for hmac_md5 */
19190 *edata_ptr
++ = 0x80;
19192 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19193 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19194 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19195 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19197 salt
->salt_len
= 32;
19199 digest
[0] = krb5tgs
->checksum
[0];
19200 digest
[1] = krb5tgs
->checksum
[1];
19201 digest
[2] = krb5tgs
->checksum
[2];
19202 digest
[3] = krb5tgs
->checksum
[3];
19204 return (PARSER_OK
);
19207 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19209 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19211 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19213 u32
*digest
= (u32
*) hash_buf
->digest
;
19215 salt_t
*salt
= hash_buf
->salt
;
19222 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19226 char *wrapped_key_pos
;
19230 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19232 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19234 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19236 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19241 data_pos
= salt_pos
;
19243 wrapped_key_pos
= strchr (salt_pos
, '*');
19245 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19247 uint salt_len
= wrapped_key_pos
- salt_pos
;
19249 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19254 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19256 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19258 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19259 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19260 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19261 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19265 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19266 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19267 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19268 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19269 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19270 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19272 salt
->salt_len
= 40;
19274 digest
[0] = salt
->salt_buf
[0];
19275 digest
[1] = salt
->salt_buf
[1];
19276 digest
[2] = salt
->salt_buf
[2];
19277 digest
[3] = salt
->salt_buf
[3];
19279 return (PARSER_OK
);
19282 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19284 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19286 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19288 u32
*digest
= (u32
*) hash_buf
->digest
;
19290 salt_t
*salt
= hash_buf
->salt
;
19292 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19302 char *algorithm_pos
;
19304 char *final_random_seed_pos
;
19305 u32 final_random_seed_len
;
19307 char *transf_random_seed_pos
;
19308 u32 transf_random_seed_len
;
19313 /* default is no keyfile provided */
19314 char *keyfile_len_pos
;
19315 u32 keyfile_len
= 0;
19316 u32 is_keyfile_present
= 0;
19317 char *keyfile_inline_pos
;
19320 /* specific to version 1 */
19321 char *contents_len_pos
;
19323 char *contents_pos
;
19325 /* specific to version 2 */
19326 char *expected_bytes_pos
;
19327 u32 expected_bytes_len
;
19329 char *contents_hash_pos
;
19330 u32 contents_hash_len
;
19332 version_pos
= input_buf
+ 8 + 1 + 1;
19334 keepass
->version
= atoi (version_pos
);
19336 rounds_pos
= strchr (version_pos
, '*');
19338 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19342 salt
->salt_iter
= (atoi (rounds_pos
));
19344 algorithm_pos
= strchr (rounds_pos
, '*');
19346 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19350 keepass
->algorithm
= atoi (algorithm_pos
);
19352 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19354 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19356 final_random_seed_pos
++;
19358 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19359 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19360 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19361 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19363 if (keepass
->version
== 2)
19365 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19366 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19367 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19368 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19371 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19373 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19375 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19377 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19378 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19380 transf_random_seed_pos
++;
19382 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19383 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19384 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19385 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19386 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19387 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19388 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19389 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19391 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19393 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19395 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19397 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19401 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19402 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19403 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19404 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19406 if (keepass
->version
== 1)
19408 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19410 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19412 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19414 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19416 contents_hash_pos
++;
19418 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19419 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19420 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19421 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19422 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19423 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19424 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19425 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19427 /* get length of contents following */
19428 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19430 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19432 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19434 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19438 u32 inline_flag
= atoi (inline_flag_pos
);
19440 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19442 contents_len_pos
= strchr (inline_flag_pos
, '*');
19444 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19446 contents_len_pos
++;
19448 contents_len
= atoi (contents_len_pos
);
19450 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19452 contents_pos
= strchr (contents_len_pos
, '*');
19454 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19460 keepass
->contents_len
= contents_len
;
19462 contents_len
= contents_len
/ 4;
19464 keyfile_inline_pos
= strchr (contents_pos
, '*');
19466 u32 real_contents_len
;
19468 if (keyfile_inline_pos
== NULL
)
19469 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19472 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19473 keyfile_inline_pos
++;
19474 is_keyfile_present
= 1;
19477 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19479 for (i
= 0; i
< contents_len
; i
++)
19480 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19482 else if (keepass
->version
== 2)
19484 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19486 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19488 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19490 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19492 expected_bytes_pos
++;
19494 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19495 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19496 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19497 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19498 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19499 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19500 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19501 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19503 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19505 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19507 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19509 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19511 contents_hash_pos
++;
19513 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19514 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19515 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19516 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19517 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19518 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19519 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19520 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19522 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19524 if (keyfile_inline_pos
== NULL
)
19525 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19528 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19529 keyfile_inline_pos
++;
19530 is_keyfile_present
= 1;
19532 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19535 if (is_keyfile_present
!= 0)
19537 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19541 keyfile_len
= atoi (keyfile_len_pos
);
19543 keepass
->keyfile_len
= keyfile_len
;
19545 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19547 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19549 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19553 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19555 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19557 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19558 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19559 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19560 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19561 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19562 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19563 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19564 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19567 digest
[0] = keepass
->enc_iv
[0];
19568 digest
[1] = keepass
->enc_iv
[1];
19569 digest
[2] = keepass
->enc_iv
[2];
19570 digest
[3] = keepass
->enc_iv
[3];
19572 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19573 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19574 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19575 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19576 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19577 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19578 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19579 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19581 return (PARSER_OK
);
19584 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19586 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19588 u32
*digest
= (u32
*) hash_buf
->digest
;
19590 salt_t
*salt
= hash_buf
->salt
;
19592 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19593 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19594 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19595 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19596 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19597 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19598 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19599 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19601 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19603 uint salt_len
= input_len
- 64 - 1;
19605 char *salt_buf
= input_buf
+ 64 + 1;
19607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19609 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19613 salt
->salt_len
= salt_len
;
19616 * we can precompute the first sha256 transform
19619 uint w
[16] = { 0 };
19621 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19622 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19623 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19624 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19625 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19626 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19627 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19628 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19629 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19630 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19631 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19632 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19633 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19634 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19635 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19636 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19638 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19640 sha256_64 (w
, pc256
);
19642 salt
->salt_buf_pc
[0] = pc256
[0];
19643 salt
->salt_buf_pc
[1] = pc256
[1];
19644 salt
->salt_buf_pc
[2] = pc256
[2];
19645 salt
->salt_buf_pc
[3] = pc256
[3];
19646 salt
->salt_buf_pc
[4] = pc256
[4];
19647 salt
->salt_buf_pc
[5] = pc256
[5];
19648 salt
->salt_buf_pc
[6] = pc256
[6];
19649 salt
->salt_buf_pc
[7] = pc256
[7];
19651 digest
[0] -= pc256
[0];
19652 digest
[1] -= pc256
[1];
19653 digest
[2] -= pc256
[2];
19654 digest
[3] -= pc256
[3];
19655 digest
[4] -= pc256
[4];
19656 digest
[5] -= pc256
[5];
19657 digest
[6] -= pc256
[6];
19658 digest
[7] -= pc256
[7];
19660 return (PARSER_OK
);
19663 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19665 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19667 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19669 u32
*digest
= (u32
*) hash_buf
->digest
;
19671 salt_t
*salt
= hash_buf
->salt
;
19677 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19679 char *data_buf_pos
= strchr (data_len_pos
, '$');
19681 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19683 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19685 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19686 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19690 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19692 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19694 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19696 u32 data_len
= atoi (data_len_pos
);
19698 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19704 char *salt_pos
= data_buf_pos
;
19706 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19707 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19708 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19709 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19711 // this is actually the CT, which is also the hash later (if matched)
19713 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19714 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19715 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19716 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19718 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19720 salt
->salt_iter
= 10 - 1;
19726 digest
[0] = salt
->salt_buf
[4];
19727 digest
[1] = salt
->salt_buf
[5];
19728 digest
[2] = salt
->salt_buf
[6];
19729 digest
[3] = salt
->salt_buf
[7];
19731 return (PARSER_OK
);
19734 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19736 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19738 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19740 u32
*digest
= (u32
*) hash_buf
->digest
;
19742 salt_t
*salt
= hash_buf
->salt
;
19748 char *salt_pos
= input_buf
+ 11 + 1;
19750 char *iter_pos
= strchr (salt_pos
, ',');
19752 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19754 u32 salt_len
= iter_pos
- salt_pos
;
19756 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19760 char *hash_pos
= strchr (iter_pos
, ',');
19762 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19764 u32 iter_len
= hash_pos
- iter_pos
;
19766 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19770 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19772 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19778 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19779 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19780 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19781 salt
->salt_buf
[3] = 0x00018000;
19783 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19784 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19785 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19786 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19788 salt
->salt_len
= salt_len
/ 2;
19790 salt
->salt_iter
= atoi (iter_pos
) - 1;
19796 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19797 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19798 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19799 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19800 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19801 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19802 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19803 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19805 return (PARSER_OK
);
19808 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19810 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19812 u32
*digest
= (u32
*) hash_buf
->digest
;
19814 salt_t
*salt
= hash_buf
->salt
;
19820 char *hash_pos
= input_buf
+ 64;
19821 char *salt1_pos
= input_buf
+ 128;
19822 char *salt2_pos
= input_buf
;
19828 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19829 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19830 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19831 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19833 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19834 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19835 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19836 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19838 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19839 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19840 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19841 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19843 salt
->salt_len
= 48;
19845 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19851 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19852 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19853 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19854 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19855 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19856 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19857 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19858 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19860 return (PARSER_OK
);
19864 * parallel running threads
19869 BOOL WINAPI
sigHandler_default (DWORD sig
)
19873 case CTRL_CLOSE_EVENT
:
19876 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19877 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19878 * function otherwise it is too late (e.g. after returning from this function)
19883 SetConsoleCtrlHandler (NULL
, TRUE
);
19890 case CTRL_LOGOFF_EVENT
:
19891 case CTRL_SHUTDOWN_EVENT
:
19895 SetConsoleCtrlHandler (NULL
, TRUE
);
19903 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19907 case CTRL_CLOSE_EVENT
:
19911 SetConsoleCtrlHandler (NULL
, TRUE
);
19918 case CTRL_LOGOFF_EVENT
:
19919 case CTRL_SHUTDOWN_EVENT
:
19923 SetConsoleCtrlHandler (NULL
, TRUE
);
19931 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19933 if (callback
== NULL
)
19935 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19939 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19945 void sigHandler_default (int sig
)
19949 signal (sig
, NULL
);
19952 void sigHandler_benchmark (int sig
)
19956 signal (sig
, NULL
);
19959 void hc_signal (void (callback
) (int))
19961 if (callback
== NULL
) callback
= SIG_DFL
;
19963 signal (SIGINT
, callback
);
19964 signal (SIGTERM
, callback
);
19965 signal (SIGABRT
, callback
);
19970 void status_display ();
19972 void *thread_keypress (void *p
)
19974 int benchmark
= *((int *) p
);
19976 uint quiet
= data
.quiet
;
19980 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19982 int ch
= tty_getchar();
19984 if (ch
== -1) break;
19986 if (ch
== 0) continue;
19988 //https://github.com/hashcat/oclHashcat/issues/302
19993 hc_thread_mutex_lock (mux_display
);
20009 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20010 if (quiet
== 0) fflush (stdout
);
20022 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20023 if (quiet
== 0) fflush (stdout
);
20035 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20036 if (quiet
== 0) fflush (stdout
);
20048 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20049 if (quiet
== 0) fflush (stdout
);
20057 if (benchmark
== 1) break;
20059 stop_at_checkpoint ();
20063 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20064 if (quiet
== 0) fflush (stdout
);
20072 if (benchmark
== 1)
20084 //https://github.com/hashcat/oclHashcat/issues/302
20089 hc_thread_mutex_unlock (mux_display
);
20101 bool class_num (const u8 c
)
20103 return ((c
>= '0') && (c
<= '9'));
20106 bool class_lower (const u8 c
)
20108 return ((c
>= 'a') && (c
<= 'z'));
20111 bool class_upper (const u8 c
)
20113 return ((c
>= 'A') && (c
<= 'Z'));
20116 bool class_alpha (const u8 c
)
20118 return (class_lower (c
) || class_upper (c
));
20121 int conv_ctoi (const u8 c
)
20127 else if (class_upper (c
))
20129 return c
- 'A' + 10;
20135 int conv_itoc (const u8 c
)
20143 return c
+ 'A' - 10;
20153 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20154 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20155 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20156 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20157 #define MAX_KERNEL_RULES 255
20158 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20159 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20160 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20162 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20163 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20164 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20165 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20167 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20172 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20174 switch (rule_buf
[rule_pos
])
20180 case RULE_OP_MANGLE_NOOP
:
20181 SET_NAME (rule
, rule_buf
[rule_pos
]);
20184 case RULE_OP_MANGLE_LREST
:
20185 SET_NAME (rule
, rule_buf
[rule_pos
]);
20188 case RULE_OP_MANGLE_UREST
:
20189 SET_NAME (rule
, rule_buf
[rule_pos
]);
20192 case RULE_OP_MANGLE_LREST_UFIRST
:
20193 SET_NAME (rule
, rule_buf
[rule_pos
]);
20196 case RULE_OP_MANGLE_UREST_LFIRST
:
20197 SET_NAME (rule
, rule_buf
[rule_pos
]);
20200 case RULE_OP_MANGLE_TREST
:
20201 SET_NAME (rule
, rule_buf
[rule_pos
]);
20204 case RULE_OP_MANGLE_TOGGLE_AT
:
20205 SET_NAME (rule
, rule_buf
[rule_pos
]);
20206 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20209 case RULE_OP_MANGLE_REVERSE
:
20210 SET_NAME (rule
, rule_buf
[rule_pos
]);
20213 case RULE_OP_MANGLE_DUPEWORD
:
20214 SET_NAME (rule
, rule_buf
[rule_pos
]);
20217 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20218 SET_NAME (rule
, rule_buf
[rule_pos
]);
20219 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20222 case RULE_OP_MANGLE_REFLECT
:
20223 SET_NAME (rule
, rule_buf
[rule_pos
]);
20226 case RULE_OP_MANGLE_ROTATE_LEFT
:
20227 SET_NAME (rule
, rule_buf
[rule_pos
]);
20230 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20231 SET_NAME (rule
, rule_buf
[rule_pos
]);
20234 case RULE_OP_MANGLE_APPEND
:
20235 SET_NAME (rule
, rule_buf
[rule_pos
]);
20236 SET_P0 (rule
, rule_buf
[rule_pos
]);
20239 case RULE_OP_MANGLE_PREPEND
:
20240 SET_NAME (rule
, rule_buf
[rule_pos
]);
20241 SET_P0 (rule
, rule_buf
[rule_pos
]);
20244 case RULE_OP_MANGLE_DELETE_FIRST
:
20245 SET_NAME (rule
, rule_buf
[rule_pos
]);
20248 case RULE_OP_MANGLE_DELETE_LAST
:
20249 SET_NAME (rule
, rule_buf
[rule_pos
]);
20252 case RULE_OP_MANGLE_DELETE_AT
:
20253 SET_NAME (rule
, rule_buf
[rule_pos
]);
20254 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20257 case RULE_OP_MANGLE_EXTRACT
:
20258 SET_NAME (rule
, rule_buf
[rule_pos
]);
20259 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20260 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20263 case RULE_OP_MANGLE_OMIT
:
20264 SET_NAME (rule
, rule_buf
[rule_pos
]);
20265 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20266 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20269 case RULE_OP_MANGLE_INSERT
:
20270 SET_NAME (rule
, rule_buf
[rule_pos
]);
20271 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20272 SET_P1 (rule
, rule_buf
[rule_pos
]);
20275 case RULE_OP_MANGLE_OVERSTRIKE
:
20276 SET_NAME (rule
, rule_buf
[rule_pos
]);
20277 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20278 SET_P1 (rule
, rule_buf
[rule_pos
]);
20281 case RULE_OP_MANGLE_TRUNCATE_AT
:
20282 SET_NAME (rule
, rule_buf
[rule_pos
]);
20283 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20286 case RULE_OP_MANGLE_REPLACE
:
20287 SET_NAME (rule
, rule_buf
[rule_pos
]);
20288 SET_P0 (rule
, rule_buf
[rule_pos
]);
20289 SET_P1 (rule
, rule_buf
[rule_pos
]);
20292 case RULE_OP_MANGLE_PURGECHAR
:
20296 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20300 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20301 SET_NAME (rule
, rule_buf
[rule_pos
]);
20302 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20305 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20306 SET_NAME (rule
, rule_buf
[rule_pos
]);
20307 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20310 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20311 SET_NAME (rule
, rule_buf
[rule_pos
]);
20314 case RULE_OP_MANGLE_SWITCH_FIRST
:
20315 SET_NAME (rule
, rule_buf
[rule_pos
]);
20318 case RULE_OP_MANGLE_SWITCH_LAST
:
20319 SET_NAME (rule
, rule_buf
[rule_pos
]);
20322 case RULE_OP_MANGLE_SWITCH_AT
:
20323 SET_NAME (rule
, rule_buf
[rule_pos
]);
20324 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20325 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20328 case RULE_OP_MANGLE_CHR_SHIFTL
:
20329 SET_NAME (rule
, rule_buf
[rule_pos
]);
20330 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20333 case RULE_OP_MANGLE_CHR_SHIFTR
:
20334 SET_NAME (rule
, rule_buf
[rule_pos
]);
20335 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20338 case RULE_OP_MANGLE_CHR_INCR
:
20339 SET_NAME (rule
, rule_buf
[rule_pos
]);
20340 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20343 case RULE_OP_MANGLE_CHR_DECR
:
20344 SET_NAME (rule
, rule_buf
[rule_pos
]);
20345 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20348 case RULE_OP_MANGLE_REPLACE_NP1
:
20349 SET_NAME (rule
, rule_buf
[rule_pos
]);
20350 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20353 case RULE_OP_MANGLE_REPLACE_NM1
:
20354 SET_NAME (rule
, rule_buf
[rule_pos
]);
20355 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20358 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20359 SET_NAME (rule
, rule_buf
[rule_pos
]);
20360 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20363 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20364 SET_NAME (rule
, rule_buf
[rule_pos
]);
20365 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20368 case RULE_OP_MANGLE_TITLE
:
20369 SET_NAME (rule
, rule_buf
[rule_pos
]);
20378 if (rule_pos
< rule_len
) return (-1);
20383 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20387 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20391 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20395 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20399 case RULE_OP_MANGLE_NOOP
:
20400 rule_buf
[rule_pos
] = rule_cmd
;
20403 case RULE_OP_MANGLE_LREST
:
20404 rule_buf
[rule_pos
] = rule_cmd
;
20407 case RULE_OP_MANGLE_UREST
:
20408 rule_buf
[rule_pos
] = rule_cmd
;
20411 case RULE_OP_MANGLE_LREST_UFIRST
:
20412 rule_buf
[rule_pos
] = rule_cmd
;
20415 case RULE_OP_MANGLE_UREST_LFIRST
:
20416 rule_buf
[rule_pos
] = rule_cmd
;
20419 case RULE_OP_MANGLE_TREST
:
20420 rule_buf
[rule_pos
] = rule_cmd
;
20423 case RULE_OP_MANGLE_TOGGLE_AT
:
20424 rule_buf
[rule_pos
] = rule_cmd
;
20425 GET_P0_CONV (rule
);
20428 case RULE_OP_MANGLE_REVERSE
:
20429 rule_buf
[rule_pos
] = rule_cmd
;
20432 case RULE_OP_MANGLE_DUPEWORD
:
20433 rule_buf
[rule_pos
] = rule_cmd
;
20436 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20437 rule_buf
[rule_pos
] = rule_cmd
;
20438 GET_P0_CONV (rule
);
20441 case RULE_OP_MANGLE_REFLECT
:
20442 rule_buf
[rule_pos
] = rule_cmd
;
20445 case RULE_OP_MANGLE_ROTATE_LEFT
:
20446 rule_buf
[rule_pos
] = rule_cmd
;
20449 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20450 rule_buf
[rule_pos
] = rule_cmd
;
20453 case RULE_OP_MANGLE_APPEND
:
20454 rule_buf
[rule_pos
] = rule_cmd
;
20458 case RULE_OP_MANGLE_PREPEND
:
20459 rule_buf
[rule_pos
] = rule_cmd
;
20463 case RULE_OP_MANGLE_DELETE_FIRST
:
20464 rule_buf
[rule_pos
] = rule_cmd
;
20467 case RULE_OP_MANGLE_DELETE_LAST
:
20468 rule_buf
[rule_pos
] = rule_cmd
;
20471 case RULE_OP_MANGLE_DELETE_AT
:
20472 rule_buf
[rule_pos
] = rule_cmd
;
20473 GET_P0_CONV (rule
);
20476 case RULE_OP_MANGLE_EXTRACT
:
20477 rule_buf
[rule_pos
] = rule_cmd
;
20478 GET_P0_CONV (rule
);
20479 GET_P1_CONV (rule
);
20482 case RULE_OP_MANGLE_OMIT
:
20483 rule_buf
[rule_pos
] = rule_cmd
;
20484 GET_P0_CONV (rule
);
20485 GET_P1_CONV (rule
);
20488 case RULE_OP_MANGLE_INSERT
:
20489 rule_buf
[rule_pos
] = rule_cmd
;
20490 GET_P0_CONV (rule
);
20494 case RULE_OP_MANGLE_OVERSTRIKE
:
20495 rule_buf
[rule_pos
] = rule_cmd
;
20496 GET_P0_CONV (rule
);
20500 case RULE_OP_MANGLE_TRUNCATE_AT
:
20501 rule_buf
[rule_pos
] = rule_cmd
;
20502 GET_P0_CONV (rule
);
20505 case RULE_OP_MANGLE_REPLACE
:
20506 rule_buf
[rule_pos
] = rule_cmd
;
20511 case RULE_OP_MANGLE_PURGECHAR
:
20515 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20519 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20520 rule_buf
[rule_pos
] = rule_cmd
;
20521 GET_P0_CONV (rule
);
20524 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20525 rule_buf
[rule_pos
] = rule_cmd
;
20526 GET_P0_CONV (rule
);
20529 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20530 rule_buf
[rule_pos
] = rule_cmd
;
20533 case RULE_OP_MANGLE_SWITCH_FIRST
:
20534 rule_buf
[rule_pos
] = rule_cmd
;
20537 case RULE_OP_MANGLE_SWITCH_LAST
:
20538 rule_buf
[rule_pos
] = rule_cmd
;
20541 case RULE_OP_MANGLE_SWITCH_AT
:
20542 rule_buf
[rule_pos
] = rule_cmd
;
20543 GET_P0_CONV (rule
);
20544 GET_P1_CONV (rule
);
20547 case RULE_OP_MANGLE_CHR_SHIFTL
:
20548 rule_buf
[rule_pos
] = rule_cmd
;
20549 GET_P0_CONV (rule
);
20552 case RULE_OP_MANGLE_CHR_SHIFTR
:
20553 rule_buf
[rule_pos
] = rule_cmd
;
20554 GET_P0_CONV (rule
);
20557 case RULE_OP_MANGLE_CHR_INCR
:
20558 rule_buf
[rule_pos
] = rule_cmd
;
20559 GET_P0_CONV (rule
);
20562 case RULE_OP_MANGLE_CHR_DECR
:
20563 rule_buf
[rule_pos
] = rule_cmd
;
20564 GET_P0_CONV (rule
);
20567 case RULE_OP_MANGLE_REPLACE_NP1
:
20568 rule_buf
[rule_pos
] = rule_cmd
;
20569 GET_P0_CONV (rule
);
20572 case RULE_OP_MANGLE_REPLACE_NM1
:
20573 rule_buf
[rule_pos
] = rule_cmd
;
20574 GET_P0_CONV (rule
);
20577 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20578 rule_buf
[rule_pos
] = rule_cmd
;
20579 GET_P0_CONV (rule
);
20582 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20583 rule_buf
[rule_pos
] = rule_cmd
;
20584 GET_P0_CONV (rule
);
20587 case RULE_OP_MANGLE_TITLE
:
20588 rule_buf
[rule_pos
] = rule_cmd
;
20592 return rule_pos
- 1;
20610 * CPU rules : this is from hashcat sources, cpu based rules
20613 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20614 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20616 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20617 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20618 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20620 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20621 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20622 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20624 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20628 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20633 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20637 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20642 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20646 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20651 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20656 for (l
= 0; l
< arr_len
; l
++)
20658 r
= arr_len
- 1 - l
;
20662 MANGLE_SWITCH (arr
, l
, r
);
20668 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20670 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20672 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20674 return (arr_len
* 2);
20677 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20679 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20681 int orig_len
= arr_len
;
20685 for (i
= 0; i
< times
; i
++)
20687 memcpy (&arr
[arr_len
], arr
, orig_len
);
20689 arr_len
+= orig_len
;
20695 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20697 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20699 mangle_double (arr
, arr_len
);
20701 mangle_reverse (arr
+ arr_len
, arr_len
);
20703 return (arr_len
* 2);
20706 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20711 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20713 MANGLE_SWITCH (arr
, l
, r
);
20719 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20724 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20726 MANGLE_SWITCH (arr
, l
, r
);
20732 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20734 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20738 return (arr_len
+ 1);
20741 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20743 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20747 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20749 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20754 return (arr_len
+ 1);
20757 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20759 if (upos
>= arr_len
) return (arr_len
);
20763 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20765 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20768 return (arr_len
- 1);
20771 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20773 if (upos
>= arr_len
) return (arr_len
);
20775 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20779 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20781 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20787 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20789 if (upos
>= arr_len
) return (arr_len
);
20791 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20795 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20797 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20800 return (arr_len
- ulen
);
20803 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20805 if (upos
>= arr_len
) return (arr_len
);
20807 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20811 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20813 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20818 return (arr_len
+ 1);
20821 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
)
20823 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20825 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20827 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20829 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20831 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20833 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20835 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20837 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20839 return (arr_len
+ arr2_cpy
);
20842 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20844 if (upos
>= arr_len
) return (arr_len
);
20851 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20853 if (upos
>= arr_len
) return (arr_len
);
20855 memset (arr
+ upos
, 0, arr_len
- upos
);
20860 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20864 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20866 if (arr
[arr_pos
] != oldc
) continue;
20868 arr
[arr_pos
] = newc
;
20874 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20880 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20882 if (arr
[arr_pos
] == c
) continue;
20884 arr
[ret_len
] = arr
[arr_pos
];
20892 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20894 if (ulen
> arr_len
) return (arr_len
);
20896 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20898 char cs
[100] = { 0 };
20900 memcpy (cs
, arr
, ulen
);
20904 for (i
= 0; i
< ulen
; i
++)
20908 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20914 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20916 if (ulen
> arr_len
) return (arr_len
);
20918 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20920 int upos
= arr_len
- ulen
;
20924 for (i
= 0; i
< ulen
; i
++)
20926 char c
= arr
[upos
+ i
];
20928 arr_len
= mangle_append (arr
, arr_len
, c
);
20934 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20936 if ( arr_len
== 0) return (arr_len
);
20937 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20939 char c
= arr
[upos
];
20943 for (i
= 0; i
< ulen
; i
++)
20945 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20951 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20953 if ( arr_len
== 0) return (arr_len
);
20954 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20958 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20960 int new_pos
= arr_pos
* 2;
20962 arr
[new_pos
] = arr
[arr_pos
];
20964 arr
[new_pos
+ 1] = arr
[arr_pos
];
20967 return (arr_len
* 2);
20970 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20972 if (upos
>= arr_len
) return (arr_len
);
20973 if (upos2
>= arr_len
) return (arr_len
);
20975 MANGLE_SWITCH (arr
, upos
, upos2
);
20980 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20982 MANGLE_SWITCH (arr
, upos
, upos2
);
20987 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20989 if (upos
>= arr_len
) return (arr_len
);
20996 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20998 if (upos
>= arr_len
) return (arr_len
);
21005 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21007 if (upos
>= arr_len
) return (arr_len
);
21014 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21016 if (upos
>= arr_len
) return (arr_len
);
21023 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21025 int upper_next
= 1;
21029 for (pos
= 0; pos
< arr_len
; pos
++)
21031 if (arr
[pos
] == ' ')
21042 MANGLE_UPPER_AT (arr
, pos
);
21046 MANGLE_LOWER_AT (arr
, pos
);
21053 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21055 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21061 for (j
= 0; j
< rp_gen_num
; j
++)
21068 switch ((char) get_random_num (0, 9))
21071 r
= get_random_num (0, sizeof (grp_op_nop
));
21072 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21076 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21077 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21078 p1
= get_random_num (0, sizeof (grp_pos
));
21079 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21083 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21084 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21085 p1
= get_random_num (1, 6);
21086 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21090 r
= get_random_num (0, sizeof (grp_op_chr
));
21091 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21092 p1
= get_random_num (0x20, 0x7e);
21093 rule_buf
[rule_pos
++] = (char) p1
;
21097 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21098 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21099 p1
= get_random_num (0x20, 0x7e);
21100 rule_buf
[rule_pos
++] = (char) p1
;
21101 p2
= get_random_num (0x20, 0x7e);
21103 p2
= get_random_num (0x20, 0x7e);
21104 rule_buf
[rule_pos
++] = (char) p2
;
21108 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21109 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21110 p1
= get_random_num (0, sizeof (grp_pos
));
21111 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21112 p2
= get_random_num (0x20, 0x7e);
21113 rule_buf
[rule_pos
++] = (char) p2
;
21117 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21118 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21119 p1
= get_random_num (0, sizeof (grp_pos
));
21120 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21121 p2
= get_random_num (0, sizeof (grp_pos
));
21123 p2
= get_random_num (0, sizeof (grp_pos
));
21124 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21128 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21129 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21130 p1
= get_random_num (0, sizeof (grp_pos
));
21131 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21132 p2
= get_random_num (1, sizeof (grp_pos
));
21134 p2
= get_random_num (1, sizeof (grp_pos
));
21135 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21139 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21140 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21141 p1
= get_random_num (0, sizeof (grp_pos
));
21142 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21143 p2
= get_random_num (1, sizeof (grp_pos
));
21144 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21145 p3
= get_random_num (0, sizeof (grp_pos
));
21146 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21154 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21156 char mem
[BLOCK_SIZE
] = { 0 };
21158 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21160 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21162 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21164 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21166 int out_len
= in_len
;
21167 int mem_len
= in_len
;
21169 memcpy (out
, in
, out_len
);
21173 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21178 switch (rule
[rule_pos
])
21183 case RULE_OP_MANGLE_NOOP
:
21186 case RULE_OP_MANGLE_LREST
:
21187 out_len
= mangle_lrest (out
, out_len
);
21190 case RULE_OP_MANGLE_UREST
:
21191 out_len
= mangle_urest (out
, out_len
);
21194 case RULE_OP_MANGLE_LREST_UFIRST
:
21195 out_len
= mangle_lrest (out
, out_len
);
21196 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21199 case RULE_OP_MANGLE_UREST_LFIRST
:
21200 out_len
= mangle_urest (out
, out_len
);
21201 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21204 case RULE_OP_MANGLE_TREST
:
21205 out_len
= mangle_trest (out
, out_len
);
21208 case RULE_OP_MANGLE_TOGGLE_AT
:
21209 NEXT_RULEPOS (rule_pos
);
21210 NEXT_RPTOI (rule
, rule_pos
, upos
);
21211 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21214 case RULE_OP_MANGLE_REVERSE
:
21215 out_len
= mangle_reverse (out
, out_len
);
21218 case RULE_OP_MANGLE_DUPEWORD
:
21219 out_len
= mangle_double (out
, out_len
);
21222 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21223 NEXT_RULEPOS (rule_pos
);
21224 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21225 out_len
= mangle_double_times (out
, out_len
, ulen
);
21228 case RULE_OP_MANGLE_REFLECT
:
21229 out_len
= mangle_reflect (out
, out_len
);
21232 case RULE_OP_MANGLE_ROTATE_LEFT
:
21233 mangle_rotate_left (out
, out_len
);
21236 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21237 mangle_rotate_right (out
, out_len
);
21240 case RULE_OP_MANGLE_APPEND
:
21241 NEXT_RULEPOS (rule_pos
);
21242 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21245 case RULE_OP_MANGLE_PREPEND
:
21246 NEXT_RULEPOS (rule_pos
);
21247 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21250 case RULE_OP_MANGLE_DELETE_FIRST
:
21251 out_len
= mangle_delete_at (out
, out_len
, 0);
21254 case RULE_OP_MANGLE_DELETE_LAST
:
21255 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21258 case RULE_OP_MANGLE_DELETE_AT
:
21259 NEXT_RULEPOS (rule_pos
);
21260 NEXT_RPTOI (rule
, rule_pos
, upos
);
21261 out_len
= mangle_delete_at (out
, out_len
, upos
);
21264 case RULE_OP_MANGLE_EXTRACT
:
21265 NEXT_RULEPOS (rule_pos
);
21266 NEXT_RPTOI (rule
, rule_pos
, upos
);
21267 NEXT_RULEPOS (rule_pos
);
21268 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21269 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21272 case RULE_OP_MANGLE_OMIT
:
21273 NEXT_RULEPOS (rule_pos
);
21274 NEXT_RPTOI (rule
, rule_pos
, upos
);
21275 NEXT_RULEPOS (rule_pos
);
21276 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21277 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21280 case RULE_OP_MANGLE_INSERT
:
21281 NEXT_RULEPOS (rule_pos
);
21282 NEXT_RPTOI (rule
, rule_pos
, upos
);
21283 NEXT_RULEPOS (rule_pos
);
21284 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21287 case RULE_OP_MANGLE_OVERSTRIKE
:
21288 NEXT_RULEPOS (rule_pos
);
21289 NEXT_RPTOI (rule
, rule_pos
, upos
);
21290 NEXT_RULEPOS (rule_pos
);
21291 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21294 case RULE_OP_MANGLE_TRUNCATE_AT
:
21295 NEXT_RULEPOS (rule_pos
);
21296 NEXT_RPTOI (rule
, rule_pos
, upos
);
21297 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21300 case RULE_OP_MANGLE_REPLACE
:
21301 NEXT_RULEPOS (rule_pos
);
21302 NEXT_RULEPOS (rule_pos
);
21303 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21306 case RULE_OP_MANGLE_PURGECHAR
:
21307 NEXT_RULEPOS (rule_pos
);
21308 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21311 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21315 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21316 NEXT_RULEPOS (rule_pos
);
21317 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21318 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21321 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21322 NEXT_RULEPOS (rule_pos
);
21323 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21324 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21327 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21328 out_len
= mangle_dupechar (out
, out_len
);
21331 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21332 NEXT_RULEPOS (rule_pos
);
21333 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21334 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21337 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21338 NEXT_RULEPOS (rule_pos
);
21339 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21340 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21343 case RULE_OP_MANGLE_SWITCH_FIRST
:
21344 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21347 case RULE_OP_MANGLE_SWITCH_LAST
:
21348 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21351 case RULE_OP_MANGLE_SWITCH_AT
:
21352 NEXT_RULEPOS (rule_pos
);
21353 NEXT_RPTOI (rule
, rule_pos
, upos
);
21354 NEXT_RULEPOS (rule_pos
);
21355 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21356 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21359 case RULE_OP_MANGLE_CHR_SHIFTL
:
21360 NEXT_RULEPOS (rule_pos
);
21361 NEXT_RPTOI (rule
, rule_pos
, upos
);
21362 mangle_chr_shiftl (out
, out_len
, upos
);
21365 case RULE_OP_MANGLE_CHR_SHIFTR
:
21366 NEXT_RULEPOS (rule_pos
);
21367 NEXT_RPTOI (rule
, rule_pos
, upos
);
21368 mangle_chr_shiftr (out
, out_len
, upos
);
21371 case RULE_OP_MANGLE_CHR_INCR
:
21372 NEXT_RULEPOS (rule_pos
);
21373 NEXT_RPTOI (rule
, rule_pos
, upos
);
21374 mangle_chr_incr (out
, out_len
, upos
);
21377 case RULE_OP_MANGLE_CHR_DECR
:
21378 NEXT_RULEPOS (rule_pos
);
21379 NEXT_RPTOI (rule
, rule_pos
, upos
);
21380 mangle_chr_decr (out
, out_len
, upos
);
21383 case RULE_OP_MANGLE_REPLACE_NP1
:
21384 NEXT_RULEPOS (rule_pos
);
21385 NEXT_RPTOI (rule
, rule_pos
, upos
);
21386 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21389 case RULE_OP_MANGLE_REPLACE_NM1
:
21390 NEXT_RULEPOS (rule_pos
);
21391 NEXT_RPTOI (rule
, rule_pos
, upos
);
21392 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21395 case RULE_OP_MANGLE_TITLE
:
21396 out_len
= mangle_title (out
, out_len
);
21399 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21400 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21401 NEXT_RULEPOS (rule_pos
);
21402 NEXT_RPTOI (rule
, rule_pos
, upos
);
21403 NEXT_RULEPOS (rule_pos
);
21404 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21405 NEXT_RULEPOS (rule_pos
);
21406 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21407 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21410 case RULE_OP_MANGLE_APPEND_MEMORY
:
21411 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21412 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21413 memcpy (out
+ out_len
, mem
, mem_len
);
21414 out_len
+= mem_len
;
21417 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21418 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21419 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21420 memcpy (mem
+ mem_len
, out
, out_len
);
21421 out_len
+= mem_len
;
21422 memcpy (out
, mem
, out_len
);
21425 case RULE_OP_MEMORIZE_WORD
:
21426 memcpy (mem
, out
, out_len
);
21430 case RULE_OP_REJECT_LESS
:
21431 NEXT_RULEPOS (rule_pos
);
21432 NEXT_RPTOI (rule
, rule_pos
, upos
);
21433 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21436 case RULE_OP_REJECT_GREATER
:
21437 NEXT_RULEPOS (rule_pos
);
21438 NEXT_RPTOI (rule
, rule_pos
, upos
);
21439 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21442 case RULE_OP_REJECT_CONTAIN
:
21443 NEXT_RULEPOS (rule_pos
);
21444 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21447 case RULE_OP_REJECT_NOT_CONTAIN
:
21448 NEXT_RULEPOS (rule_pos
);
21449 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21452 case RULE_OP_REJECT_EQUAL_FIRST
:
21453 NEXT_RULEPOS (rule_pos
);
21454 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21457 case RULE_OP_REJECT_EQUAL_LAST
:
21458 NEXT_RULEPOS (rule_pos
);
21459 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21462 case RULE_OP_REJECT_EQUAL_AT
:
21463 NEXT_RULEPOS (rule_pos
);
21464 NEXT_RPTOI (rule
, rule_pos
, upos
);
21465 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21466 NEXT_RULEPOS (rule_pos
);
21467 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21470 case RULE_OP_REJECT_CONTAINS
:
21471 NEXT_RULEPOS (rule_pos
);
21472 NEXT_RPTOI (rule
, rule_pos
, upos
);
21473 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21474 NEXT_RULEPOS (rule_pos
);
21475 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21476 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21479 case RULE_OP_REJECT_MEMORY
:
21480 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21484 return (RULE_RC_SYNTAX_ERROR
);
21489 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);