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 int 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
);
117 int log_out_nn (FILE *fp
, const char *fmt
, ...)
119 if (SUPPRESS_OUTPUT
) return 0;
125 const int len
= log_final (fp
, fmt
, ap
);
132 int log_info_nn (const char *fmt
, ...)
134 if (SUPPRESS_OUTPUT
) return 0;
140 const int len
= log_final (stdout
, fmt
, ap
);
147 int log_error_nn (const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return 0;
155 const int len
= log_final (stderr
, fmt
, ap
);
162 int log_out (FILE *fp
, const char *fmt
, ...)
164 if (SUPPRESS_OUTPUT
) return 0;
170 const int len
= log_final (fp
, fmt
, ap
);
181 int log_info (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return 0;
189 const int len
= log_final (stdout
, fmt
, ap
);
193 fputc ('\n', stdout
);
200 int log_error (const char *fmt
, ...)
202 if (SUPPRESS_OUTPUT
) return 0;
204 fputc ('\n', stderr
);
205 fputc ('\n', stderr
);
211 const int len
= log_final (stderr
, fmt
, ap
);
215 fputc ('\n', stderr
);
216 fputc ('\n', stderr
);
227 u8
int_to_base32 (const u8 c
)
229 static const u8 tbl
[0x20] =
231 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
232 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
238 u8
base32_to_int (const u8 c
)
240 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
241 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
246 u8
int_to_itoa32 (const u8 c
)
248 static const u8 tbl
[0x20] =
250 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
251 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
257 u8
itoa32_to_int (const u8 c
)
259 if ((c
>= '0') && (c
<= '9')) return c
- '0';
260 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
265 u8
int_to_itoa64 (const u8 c
)
267 static const u8 tbl
[0x40] =
269 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
270 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
271 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
272 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
278 u8
itoa64_to_int (const u8 c
)
280 static const u8 tbl
[0x100] =
282 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
283 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
284 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
285 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
286 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
287 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
288 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
289 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
290 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
291 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
292 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
293 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
294 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
295 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
296 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
297 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
303 u8
int_to_base64 (const u8 c
)
305 static const u8 tbl
[0x40] =
307 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
308 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
309 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
310 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
316 u8
base64_to_int (const u8 c
)
318 static const u8 tbl
[0x100] =
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,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
323 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
327 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 u8
int_to_bf64 (const u8 c
)
343 static const u8 tbl
[0x40] =
345 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
346 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
347 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
348 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
354 u8
bf64_to_int (const u8 c
)
356 static const u8 tbl
[0x100] =
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,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
361 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
363 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
365 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 u8
int_to_lotus64 (const u8 c
)
381 if (c
< 10) return '0' + c
;
382 else if (c
< 36) return 'A' + c
- 10;
383 else if (c
< 62) return 'a' + c
- 36;
384 else if (c
== 62) return '+';
385 else if (c
== 63) return '/';
390 u8
lotus64_to_int (const u8 c
)
392 if ((c
>= '0') && (c
<= '9')) return c
- '0';
393 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
394 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
395 else if (c
== '+') return 62;
396 else if (c
== '/') return 63;
402 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
404 const u8
*in_ptr
= in_buf
;
406 u8
*out_ptr
= out_buf
;
408 for (int i
= 0; i
< in_len
; i
+= 8)
410 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
411 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
412 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
413 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
414 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
415 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
416 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
417 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
419 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
420 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
421 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
422 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
423 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
429 for (int i
= 0; i
< in_len
; i
++)
431 if (in_buf
[i
] != '=') continue;
436 int out_len
= (in_len
* 5) / 8;
441 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
443 const u8
*in_ptr
= in_buf
;
445 u8
*out_ptr
= out_buf
;
447 for (int i
= 0; i
< in_len
; i
+= 5)
449 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
450 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
451 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
452 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
453 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
454 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
455 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
456 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
458 out_ptr
[0] = out_val0
& 0x7f;
459 out_ptr
[1] = out_val1
& 0x7f;
460 out_ptr
[2] = out_val2
& 0x7f;
461 out_ptr
[3] = out_val3
& 0x7f;
462 out_ptr
[4] = out_val4
& 0x7f;
463 out_ptr
[5] = out_val5
& 0x7f;
464 out_ptr
[6] = out_val6
& 0x7f;
465 out_ptr
[7] = out_val7
& 0x7f;
471 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
475 out_buf
[out_len
] = '=';
483 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
485 const u8
*in_ptr
= in_buf
;
487 u8
*out_ptr
= out_buf
;
489 for (int i
= 0; i
< in_len
; i
+= 4)
491 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
492 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
493 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
494 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
496 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
497 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
498 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
504 for (int i
= 0; i
< in_len
; i
++)
506 if (in_buf
[i
] != '=') continue;
511 int out_len
= (in_len
* 6) / 8;
516 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
518 const u8
*in_ptr
= in_buf
;
520 u8
*out_ptr
= out_buf
;
522 for (int i
= 0; i
< in_len
; i
+= 3)
524 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
525 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
526 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
527 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
529 out_ptr
[0] = out_val0
& 0x7f;
530 out_ptr
[1] = out_val1
& 0x7f;
531 out_ptr
[2] = out_val2
& 0x7f;
532 out_ptr
[3] = out_val3
& 0x7f;
538 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
542 out_buf
[out_len
] = '=';
550 int is_valid_hex_char (const u8 c
)
552 if ((c
>= '0') && (c
<= '9')) return 1;
553 if ((c
>= 'A') && (c
<= 'F')) return 1;
554 if ((c
>= 'a') && (c
<= 'f')) return 1;
559 u8
hex_convert (const u8 c
)
561 return (c
& 15) + (c
>> 6) * 9;
564 u8
hex_to_u8 (const u8 hex
[2])
568 v
|= (hex_convert (hex
[1]) << 0);
569 v
|= (hex_convert (hex
[0]) << 4);
574 u32
hex_to_u32 (const u8 hex
[8])
578 v
|= ((u32
) hex_convert (hex
[7])) << 0;
579 v
|= ((u32
) hex_convert (hex
[6])) << 4;
580 v
|= ((u32
) hex_convert (hex
[5])) << 8;
581 v
|= ((u32
) hex_convert (hex
[4])) << 12;
582 v
|= ((u32
) hex_convert (hex
[3])) << 16;
583 v
|= ((u32
) hex_convert (hex
[2])) << 20;
584 v
|= ((u32
) hex_convert (hex
[1])) << 24;
585 v
|= ((u32
) hex_convert (hex
[0])) << 28;
590 u64
hex_to_u64 (const u8 hex
[16])
594 v
|= ((u64
) hex_convert (hex
[15]) << 0);
595 v
|= ((u64
) hex_convert (hex
[14]) << 4);
596 v
|= ((u64
) hex_convert (hex
[13]) << 8);
597 v
|= ((u64
) hex_convert (hex
[12]) << 12);
598 v
|= ((u64
) hex_convert (hex
[11]) << 16);
599 v
|= ((u64
) hex_convert (hex
[10]) << 20);
600 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
601 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
602 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
603 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
604 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
605 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
606 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
607 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
608 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
609 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
614 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
616 hex
[0] = v
>> 28 & 15;
617 hex
[1] = v
>> 24 & 15;
618 hex
[2] = v
>> 20 & 15;
619 hex
[3] = v
>> 16 & 15;
620 hex
[4] = v
>> 12 & 15;
621 hex
[5] = v
>> 8 & 15;
622 hex
[6] = v
>> 4 & 15;
623 hex
[7] = v
>> 0 & 15;
627 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
628 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
629 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
630 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
631 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
632 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
633 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
634 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
641 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
645 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
654 for (int i
= 0; i
< 16; i
+= 4)
664 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
671 out
[i
+ 0] = _out
[0];
672 out
[i
+ 1] = _out
[1];
673 out
[i
+ 2] = _out
[2];
674 out
[i
+ 3] = _out
[3];
683 static void juniper_decrypt_hash (char *in
, char *out
)
687 u8 base64_buf
[100] = { 0 };
689 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
693 u32 juniper_iv
[4] = { 0 };
695 memcpy (juniper_iv
, base64_buf
, 12);
697 memcpy (out
, juniper_iv
, 12);
701 u32 juniper_key
[4] = { 0 };
703 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
704 juniper_key
[1] = byte_swap_32 (0x8df91059);
705 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
706 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
710 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
711 u32
*out_ptr
= (u32
*) (out
+ 12);
713 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
716 void phpass_decode (u8 digest
[16], u8 buf
[22])
720 l
= itoa64_to_int (buf
[ 0]) << 0;
721 l
|= itoa64_to_int (buf
[ 1]) << 6;
722 l
|= itoa64_to_int (buf
[ 2]) << 12;
723 l
|= itoa64_to_int (buf
[ 3]) << 18;
725 digest
[ 0] = (l
>> 0) & 0xff;
726 digest
[ 1] = (l
>> 8) & 0xff;
727 digest
[ 2] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[ 4]) << 0;
730 l
|= itoa64_to_int (buf
[ 5]) << 6;
731 l
|= itoa64_to_int (buf
[ 6]) << 12;
732 l
|= itoa64_to_int (buf
[ 7]) << 18;
734 digest
[ 3] = (l
>> 0) & 0xff;
735 digest
[ 4] = (l
>> 8) & 0xff;
736 digest
[ 5] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[ 8]) << 0;
739 l
|= itoa64_to_int (buf
[ 9]) << 6;
740 l
|= itoa64_to_int (buf
[10]) << 12;
741 l
|= itoa64_to_int (buf
[11]) << 18;
743 digest
[ 6] = (l
>> 0) & 0xff;
744 digest
[ 7] = (l
>> 8) & 0xff;
745 digest
[ 8] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[12]) << 0;
748 l
|= itoa64_to_int (buf
[13]) << 6;
749 l
|= itoa64_to_int (buf
[14]) << 12;
750 l
|= itoa64_to_int (buf
[15]) << 18;
752 digest
[ 9] = (l
>> 0) & 0xff;
753 digest
[10] = (l
>> 8) & 0xff;
754 digest
[11] = (l
>> 16) & 0xff;
756 l
= itoa64_to_int (buf
[16]) << 0;
757 l
|= itoa64_to_int (buf
[17]) << 6;
758 l
|= itoa64_to_int (buf
[18]) << 12;
759 l
|= itoa64_to_int (buf
[19]) << 18;
761 digest
[12] = (l
>> 0) & 0xff;
762 digest
[13] = (l
>> 8) & 0xff;
763 digest
[14] = (l
>> 16) & 0xff;
765 l
= itoa64_to_int (buf
[20]) << 0;
766 l
|= itoa64_to_int (buf
[21]) << 6;
768 digest
[15] = (l
>> 0) & 0xff;
771 void phpass_encode (u8 digest
[16], u8 buf
[22])
775 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
777 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
784 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
791 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[11] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
798 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
800 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[15] = int_to_itoa64 (l
& 0x3f);
803 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
805 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
807 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
808 buf
[19] = int_to_itoa64 (l
& 0x3f);
810 l
= (digest
[15] << 0);
812 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[21] = int_to_itoa64 (l
& 0x3f);
816 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
820 l
= itoa64_to_int (buf
[ 0]) << 0;
821 l
|= itoa64_to_int (buf
[ 1]) << 6;
822 l
|= itoa64_to_int (buf
[ 2]) << 12;
823 l
|= itoa64_to_int (buf
[ 3]) << 18;
825 digest
[ 0] = (l
>> 16) & 0xff;
826 digest
[ 6] = (l
>> 8) & 0xff;
827 digest
[12] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[ 4]) << 0;
830 l
|= itoa64_to_int (buf
[ 5]) << 6;
831 l
|= itoa64_to_int (buf
[ 6]) << 12;
832 l
|= itoa64_to_int (buf
[ 7]) << 18;
834 digest
[ 1] = (l
>> 16) & 0xff;
835 digest
[ 7] = (l
>> 8) & 0xff;
836 digest
[13] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[ 8]) << 0;
839 l
|= itoa64_to_int (buf
[ 9]) << 6;
840 l
|= itoa64_to_int (buf
[10]) << 12;
841 l
|= itoa64_to_int (buf
[11]) << 18;
843 digest
[ 2] = (l
>> 16) & 0xff;
844 digest
[ 8] = (l
>> 8) & 0xff;
845 digest
[14] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[12]) << 0;
848 l
|= itoa64_to_int (buf
[13]) << 6;
849 l
|= itoa64_to_int (buf
[14]) << 12;
850 l
|= itoa64_to_int (buf
[15]) << 18;
852 digest
[ 3] = (l
>> 16) & 0xff;
853 digest
[ 9] = (l
>> 8) & 0xff;
854 digest
[15] = (l
>> 0) & 0xff;
856 l
= itoa64_to_int (buf
[16]) << 0;
857 l
|= itoa64_to_int (buf
[17]) << 6;
858 l
|= itoa64_to_int (buf
[18]) << 12;
859 l
|= itoa64_to_int (buf
[19]) << 18;
861 digest
[ 4] = (l
>> 16) & 0xff;
862 digest
[10] = (l
>> 8) & 0xff;
863 digest
[ 5] = (l
>> 0) & 0xff;
865 l
= itoa64_to_int (buf
[20]) << 0;
866 l
|= itoa64_to_int (buf
[21]) << 6;
868 digest
[11] = (l
>> 0) & 0xff;
871 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
875 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
877 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
884 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
891 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
898 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
900 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
903 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
905 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
907 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
910 l
= (digest
[11] << 0);
912 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
916 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
920 l
= itoa64_to_int (buf
[ 0]) << 0;
921 l
|= itoa64_to_int (buf
[ 1]) << 6;
922 l
|= itoa64_to_int (buf
[ 2]) << 12;
923 l
|= itoa64_to_int (buf
[ 3]) << 18;
925 digest
[ 0] = (l
>> 16) & 0xff;
926 digest
[21] = (l
>> 8) & 0xff;
927 digest
[42] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[ 4]) << 0;
930 l
|= itoa64_to_int (buf
[ 5]) << 6;
931 l
|= itoa64_to_int (buf
[ 6]) << 12;
932 l
|= itoa64_to_int (buf
[ 7]) << 18;
934 digest
[22] = (l
>> 16) & 0xff;
935 digest
[43] = (l
>> 8) & 0xff;
936 digest
[ 1] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[ 8]) << 0;
939 l
|= itoa64_to_int (buf
[ 9]) << 6;
940 l
|= itoa64_to_int (buf
[10]) << 12;
941 l
|= itoa64_to_int (buf
[11]) << 18;
943 digest
[44] = (l
>> 16) & 0xff;
944 digest
[ 2] = (l
>> 8) & 0xff;
945 digest
[23] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[12]) << 0;
948 l
|= itoa64_to_int (buf
[13]) << 6;
949 l
|= itoa64_to_int (buf
[14]) << 12;
950 l
|= itoa64_to_int (buf
[15]) << 18;
952 digest
[ 3] = (l
>> 16) & 0xff;
953 digest
[24] = (l
>> 8) & 0xff;
954 digest
[45] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[16]) << 0;
957 l
|= itoa64_to_int (buf
[17]) << 6;
958 l
|= itoa64_to_int (buf
[18]) << 12;
959 l
|= itoa64_to_int (buf
[19]) << 18;
961 digest
[25] = (l
>> 16) & 0xff;
962 digest
[46] = (l
>> 8) & 0xff;
963 digest
[ 4] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[20]) << 0;
966 l
|= itoa64_to_int (buf
[21]) << 6;
967 l
|= itoa64_to_int (buf
[22]) << 12;
968 l
|= itoa64_to_int (buf
[23]) << 18;
970 digest
[47] = (l
>> 16) & 0xff;
971 digest
[ 5] = (l
>> 8) & 0xff;
972 digest
[26] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[24]) << 0;
975 l
|= itoa64_to_int (buf
[25]) << 6;
976 l
|= itoa64_to_int (buf
[26]) << 12;
977 l
|= itoa64_to_int (buf
[27]) << 18;
979 digest
[ 6] = (l
>> 16) & 0xff;
980 digest
[27] = (l
>> 8) & 0xff;
981 digest
[48] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[28]) << 0;
984 l
|= itoa64_to_int (buf
[29]) << 6;
985 l
|= itoa64_to_int (buf
[30]) << 12;
986 l
|= itoa64_to_int (buf
[31]) << 18;
988 digest
[28] = (l
>> 16) & 0xff;
989 digest
[49] = (l
>> 8) & 0xff;
990 digest
[ 7] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[32]) << 0;
993 l
|= itoa64_to_int (buf
[33]) << 6;
994 l
|= itoa64_to_int (buf
[34]) << 12;
995 l
|= itoa64_to_int (buf
[35]) << 18;
997 digest
[50] = (l
>> 16) & 0xff;
998 digest
[ 8] = (l
>> 8) & 0xff;
999 digest
[29] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[36]) << 0;
1002 l
|= itoa64_to_int (buf
[37]) << 6;
1003 l
|= itoa64_to_int (buf
[38]) << 12;
1004 l
|= itoa64_to_int (buf
[39]) << 18;
1006 digest
[ 9] = (l
>> 16) & 0xff;
1007 digest
[30] = (l
>> 8) & 0xff;
1008 digest
[51] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[40]) << 0;
1011 l
|= itoa64_to_int (buf
[41]) << 6;
1012 l
|= itoa64_to_int (buf
[42]) << 12;
1013 l
|= itoa64_to_int (buf
[43]) << 18;
1015 digest
[31] = (l
>> 16) & 0xff;
1016 digest
[52] = (l
>> 8) & 0xff;
1017 digest
[10] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[44]) << 0;
1020 l
|= itoa64_to_int (buf
[45]) << 6;
1021 l
|= itoa64_to_int (buf
[46]) << 12;
1022 l
|= itoa64_to_int (buf
[47]) << 18;
1024 digest
[53] = (l
>> 16) & 0xff;
1025 digest
[11] = (l
>> 8) & 0xff;
1026 digest
[32] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[48]) << 0;
1029 l
|= itoa64_to_int (buf
[49]) << 6;
1030 l
|= itoa64_to_int (buf
[50]) << 12;
1031 l
|= itoa64_to_int (buf
[51]) << 18;
1033 digest
[12] = (l
>> 16) & 0xff;
1034 digest
[33] = (l
>> 8) & 0xff;
1035 digest
[54] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[52]) << 0;
1038 l
|= itoa64_to_int (buf
[53]) << 6;
1039 l
|= itoa64_to_int (buf
[54]) << 12;
1040 l
|= itoa64_to_int (buf
[55]) << 18;
1042 digest
[34] = (l
>> 16) & 0xff;
1043 digest
[55] = (l
>> 8) & 0xff;
1044 digest
[13] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[56]) << 0;
1047 l
|= itoa64_to_int (buf
[57]) << 6;
1048 l
|= itoa64_to_int (buf
[58]) << 12;
1049 l
|= itoa64_to_int (buf
[59]) << 18;
1051 digest
[56] = (l
>> 16) & 0xff;
1052 digest
[14] = (l
>> 8) & 0xff;
1053 digest
[35] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[60]) << 0;
1056 l
|= itoa64_to_int (buf
[61]) << 6;
1057 l
|= itoa64_to_int (buf
[62]) << 12;
1058 l
|= itoa64_to_int (buf
[63]) << 18;
1060 digest
[15] = (l
>> 16) & 0xff;
1061 digest
[36] = (l
>> 8) & 0xff;
1062 digest
[57] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[64]) << 0;
1065 l
|= itoa64_to_int (buf
[65]) << 6;
1066 l
|= itoa64_to_int (buf
[66]) << 12;
1067 l
|= itoa64_to_int (buf
[67]) << 18;
1069 digest
[37] = (l
>> 16) & 0xff;
1070 digest
[58] = (l
>> 8) & 0xff;
1071 digest
[16] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[68]) << 0;
1074 l
|= itoa64_to_int (buf
[69]) << 6;
1075 l
|= itoa64_to_int (buf
[70]) << 12;
1076 l
|= itoa64_to_int (buf
[71]) << 18;
1078 digest
[59] = (l
>> 16) & 0xff;
1079 digest
[17] = (l
>> 8) & 0xff;
1080 digest
[38] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[72]) << 0;
1083 l
|= itoa64_to_int (buf
[73]) << 6;
1084 l
|= itoa64_to_int (buf
[74]) << 12;
1085 l
|= itoa64_to_int (buf
[75]) << 18;
1087 digest
[18] = (l
>> 16) & 0xff;
1088 digest
[39] = (l
>> 8) & 0xff;
1089 digest
[60] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[76]) << 0;
1092 l
|= itoa64_to_int (buf
[77]) << 6;
1093 l
|= itoa64_to_int (buf
[78]) << 12;
1094 l
|= itoa64_to_int (buf
[79]) << 18;
1096 digest
[40] = (l
>> 16) & 0xff;
1097 digest
[61] = (l
>> 8) & 0xff;
1098 digest
[19] = (l
>> 0) & 0xff;
1100 l
= itoa64_to_int (buf
[80]) << 0;
1101 l
|= itoa64_to_int (buf
[81]) << 6;
1102 l
|= itoa64_to_int (buf
[82]) << 12;
1103 l
|= itoa64_to_int (buf
[83]) << 18;
1105 digest
[62] = (l
>> 16) & 0xff;
1106 digest
[20] = (l
>> 8) & 0xff;
1107 digest
[41] = (l
>> 0) & 0xff;
1109 l
= itoa64_to_int (buf
[84]) << 0;
1110 l
|= itoa64_to_int (buf
[85]) << 6;
1112 digest
[63] = (l
>> 0) & 0xff;
1115 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1119 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1121 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1128 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1135 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1142 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1149 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1156 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1163 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1170 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1177 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1184 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1191 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1198 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1205 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1212 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1219 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1226 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1233 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1240 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1247 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1254 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1256 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1259 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1261 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1263 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1266 l
= 0 | 0 | (digest
[63] << 0);
1268 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1272 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1276 l
= itoa64_to_int (buf
[ 0]) << 0;
1277 l
|= itoa64_to_int (buf
[ 1]) << 6;
1278 l
|= itoa64_to_int (buf
[ 2]) << 12;
1279 l
|= itoa64_to_int (buf
[ 3]) << 18;
1281 digest
[ 2] = (l
>> 0) & 0xff;
1282 digest
[ 1] = (l
>> 8) & 0xff;
1283 digest
[ 0] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[ 4]) << 0;
1286 l
|= itoa64_to_int (buf
[ 5]) << 6;
1287 l
|= itoa64_to_int (buf
[ 6]) << 12;
1288 l
|= itoa64_to_int (buf
[ 7]) << 18;
1290 digest
[ 5] = (l
>> 0) & 0xff;
1291 digest
[ 4] = (l
>> 8) & 0xff;
1292 digest
[ 3] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[ 8]) << 0;
1295 l
|= itoa64_to_int (buf
[ 9]) << 6;
1296 l
|= itoa64_to_int (buf
[10]) << 12;
1297 l
|= itoa64_to_int (buf
[11]) << 18;
1299 digest
[ 8] = (l
>> 0) & 0xff;
1300 digest
[ 7] = (l
>> 8) & 0xff;
1301 digest
[ 6] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[12]) << 0;
1304 l
|= itoa64_to_int (buf
[13]) << 6;
1305 l
|= itoa64_to_int (buf
[14]) << 12;
1306 l
|= itoa64_to_int (buf
[15]) << 18;
1308 digest
[11] = (l
>> 0) & 0xff;
1309 digest
[10] = (l
>> 8) & 0xff;
1310 digest
[ 9] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[16]) << 0;
1313 l
|= itoa64_to_int (buf
[17]) << 6;
1314 l
|= itoa64_to_int (buf
[18]) << 12;
1315 l
|= itoa64_to_int (buf
[19]) << 18;
1317 digest
[14] = (l
>> 0) & 0xff;
1318 digest
[13] = (l
>> 8) & 0xff;
1319 digest
[12] = (l
>> 16) & 0xff;
1321 l
= itoa64_to_int (buf
[20]) << 0;
1322 l
|= itoa64_to_int (buf
[21]) << 6;
1323 l
|= itoa64_to_int (buf
[22]) << 12;
1324 l
|= itoa64_to_int (buf
[23]) << 18;
1326 digest
[17] = (l
>> 0) & 0xff;
1327 digest
[16] = (l
>> 8) & 0xff;
1328 digest
[15] = (l
>> 16) & 0xff;
1330 l
= itoa64_to_int (buf
[24]) << 0;
1331 l
|= itoa64_to_int (buf
[25]) << 6;
1332 l
|= itoa64_to_int (buf
[26]) << 12;
1334 digest
[19] = (l
>> 8) & 0xff;
1335 digest
[18] = (l
>> 16) & 0xff;
1338 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1342 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1344 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1351 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1358 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[11] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1365 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[15] = int_to_itoa64 (l
& 0x3f);
1370 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1372 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[19] = int_to_itoa64 (l
& 0x3f);
1377 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1379 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1381 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1382 buf
[23] = int_to_itoa64 (l
& 0x3f);
1384 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1386 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1388 buf
[26] = int_to_itoa64 (l
& 0x3f);
1391 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1395 l
= itoa64_to_int (buf
[ 0]) << 0;
1396 l
|= itoa64_to_int (buf
[ 1]) << 6;
1397 l
|= itoa64_to_int (buf
[ 2]) << 12;
1398 l
|= itoa64_to_int (buf
[ 3]) << 18;
1400 digest
[ 2] = (l
>> 0) & 0xff;
1401 digest
[ 1] = (l
>> 8) & 0xff;
1402 digest
[ 0] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[ 4]) << 0;
1405 l
|= itoa64_to_int (buf
[ 5]) << 6;
1406 l
|= itoa64_to_int (buf
[ 6]) << 12;
1407 l
|= itoa64_to_int (buf
[ 7]) << 18;
1409 digest
[ 5] = (l
>> 0) & 0xff;
1410 digest
[ 4] = (l
>> 8) & 0xff;
1411 digest
[ 3] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[ 8]) << 0;
1414 l
|= itoa64_to_int (buf
[ 9]) << 6;
1415 l
|= itoa64_to_int (buf
[10]) << 12;
1416 l
|= itoa64_to_int (buf
[11]) << 18;
1418 digest
[ 8] = (l
>> 0) & 0xff;
1419 digest
[ 7] = (l
>> 8) & 0xff;
1420 digest
[ 6] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[12]) << 0;
1423 l
|= itoa64_to_int (buf
[13]) << 6;
1424 l
|= itoa64_to_int (buf
[14]) << 12;
1425 l
|= itoa64_to_int (buf
[15]) << 18;
1427 digest
[11] = (l
>> 0) & 0xff;
1428 digest
[10] = (l
>> 8) & 0xff;
1429 digest
[ 9] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[16]) << 0;
1432 l
|= itoa64_to_int (buf
[17]) << 6;
1433 l
|= itoa64_to_int (buf
[18]) << 12;
1434 l
|= itoa64_to_int (buf
[19]) << 18;
1436 digest
[14] = (l
>> 0) & 0xff;
1437 digest
[13] = (l
>> 8) & 0xff;
1438 digest
[12] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[20]) << 0;
1441 l
|= itoa64_to_int (buf
[21]) << 6;
1442 l
|= itoa64_to_int (buf
[22]) << 12;
1443 l
|= itoa64_to_int (buf
[23]) << 18;
1445 digest
[17] = (l
>> 0) & 0xff;
1446 digest
[16] = (l
>> 8) & 0xff;
1447 digest
[15] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[24]) << 0;
1450 l
|= itoa64_to_int (buf
[25]) << 6;
1451 l
|= itoa64_to_int (buf
[26]) << 12;
1452 l
|= itoa64_to_int (buf
[27]) << 18;
1454 digest
[20] = (l
>> 0) & 0xff;
1455 digest
[19] = (l
>> 8) & 0xff;
1456 digest
[18] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[28]) << 0;
1459 l
|= itoa64_to_int (buf
[29]) << 6;
1460 l
|= itoa64_to_int (buf
[30]) << 12;
1461 l
|= itoa64_to_int (buf
[31]) << 18;
1463 digest
[23] = (l
>> 0) & 0xff;
1464 digest
[22] = (l
>> 8) & 0xff;
1465 digest
[21] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[32]) << 0;
1468 l
|= itoa64_to_int (buf
[33]) << 6;
1469 l
|= itoa64_to_int (buf
[34]) << 12;
1470 l
|= itoa64_to_int (buf
[35]) << 18;
1472 digest
[26] = (l
>> 0) & 0xff;
1473 digest
[25] = (l
>> 8) & 0xff;
1474 digest
[24] = (l
>> 16) & 0xff;
1476 l
= itoa64_to_int (buf
[36]) << 0;
1477 l
|= itoa64_to_int (buf
[37]) << 6;
1478 l
|= itoa64_to_int (buf
[38]) << 12;
1479 l
|= itoa64_to_int (buf
[39]) << 18;
1481 digest
[29] = (l
>> 0) & 0xff;
1482 digest
[28] = (l
>> 8) & 0xff;
1483 digest
[27] = (l
>> 16) & 0xff;
1485 l
= itoa64_to_int (buf
[40]) << 0;
1486 l
|= itoa64_to_int (buf
[41]) << 6;
1487 l
|= itoa64_to_int (buf
[42]) << 12;
1489 //digest[32] = (l >> 0) & 0xff;
1490 digest
[31] = (l
>> 8) & 0xff;
1491 digest
[30] = (l
>> 16) & 0xff;
1494 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1498 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1500 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1507 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1514 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[11] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1521 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[15] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1528 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[19] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1535 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[23] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1542 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[27] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1549 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[31] = int_to_itoa64 (l
& 0x3f);
1554 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1556 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[35] = int_to_itoa64 (l
& 0x3f);
1561 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1563 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1565 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1566 buf
[39] = int_to_itoa64 (l
& 0x3f);
1568 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1570 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1572 buf
[42] = int_to_itoa64 (l
& 0x3f);
1575 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1579 l
= itoa64_to_int (buf
[ 0]) << 0;
1580 l
|= itoa64_to_int (buf
[ 1]) << 6;
1581 l
|= itoa64_to_int (buf
[ 2]) << 12;
1582 l
|= itoa64_to_int (buf
[ 3]) << 18;
1584 digest
[ 2] = (l
>> 0) & 0xff;
1585 digest
[ 1] = (l
>> 8) & 0xff;
1586 digest
[ 0] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[ 4]) << 0;
1589 l
|= itoa64_to_int (buf
[ 5]) << 6;
1590 l
|= itoa64_to_int (buf
[ 6]) << 12;
1591 l
|= itoa64_to_int (buf
[ 7]) << 18;
1593 digest
[ 5] = (l
>> 0) & 0xff;
1594 digest
[ 4] = (l
>> 8) & 0xff;
1595 digest
[ 3] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[ 8]) << 0;
1598 l
|= itoa64_to_int (buf
[ 9]) << 6;
1599 l
|= itoa64_to_int (buf
[10]) << 12;
1600 l
|= itoa64_to_int (buf
[11]) << 18;
1602 digest
[ 8] = (l
>> 0) & 0xff;
1603 digest
[ 7] = (l
>> 8) & 0xff;
1604 digest
[ 6] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[12]) << 0;
1607 l
|= itoa64_to_int (buf
[13]) << 6;
1608 l
|= itoa64_to_int (buf
[14]) << 12;
1609 l
|= itoa64_to_int (buf
[15]) << 18;
1611 digest
[11] = (l
>> 0) & 0xff;
1612 digest
[10] = (l
>> 8) & 0xff;
1613 digest
[ 9] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[16]) << 0;
1616 l
|= itoa64_to_int (buf
[17]) << 6;
1617 l
|= itoa64_to_int (buf
[18]) << 12;
1618 l
|= itoa64_to_int (buf
[19]) << 18;
1620 digest
[14] = (l
>> 0) & 0xff;
1621 digest
[13] = (l
>> 8) & 0xff;
1622 digest
[12] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[20]) << 0;
1625 l
|= itoa64_to_int (buf
[21]) << 6;
1626 l
|= itoa64_to_int (buf
[22]) << 12;
1627 l
|= itoa64_to_int (buf
[23]) << 18;
1629 digest
[17] = (l
>> 0) & 0xff;
1630 digest
[16] = (l
>> 8) & 0xff;
1631 digest
[15] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[24]) << 0;
1634 l
|= itoa64_to_int (buf
[25]) << 6;
1635 l
|= itoa64_to_int (buf
[26]) << 12;
1636 l
|= itoa64_to_int (buf
[27]) << 18;
1638 digest
[20] = (l
>> 0) & 0xff;
1639 digest
[19] = (l
>> 8) & 0xff;
1640 digest
[18] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[28]) << 0;
1643 l
|= itoa64_to_int (buf
[29]) << 6;
1644 l
|= itoa64_to_int (buf
[30]) << 12;
1645 l
|= itoa64_to_int (buf
[31]) << 18;
1647 digest
[23] = (l
>> 0) & 0xff;
1648 digest
[22] = (l
>> 8) & 0xff;
1649 digest
[21] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[32]) << 0;
1652 l
|= itoa64_to_int (buf
[33]) << 6;
1653 l
|= itoa64_to_int (buf
[34]) << 12;
1654 l
|= itoa64_to_int (buf
[35]) << 18;
1656 digest
[26] = (l
>> 0) & 0xff;
1657 digest
[25] = (l
>> 8) & 0xff;
1658 digest
[24] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[36]) << 0;
1661 l
|= itoa64_to_int (buf
[37]) << 6;
1662 l
|= itoa64_to_int (buf
[38]) << 12;
1663 l
|= itoa64_to_int (buf
[39]) << 18;
1665 digest
[29] = (l
>> 0) & 0xff;
1666 digest
[28] = (l
>> 8) & 0xff;
1667 digest
[27] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[40]) << 0;
1670 l
|= itoa64_to_int (buf
[41]) << 6;
1671 l
|= itoa64_to_int (buf
[42]) << 12;
1672 l
|= itoa64_to_int (buf
[43]) << 18;
1674 digest
[32] = (l
>> 0) & 0xff;
1675 digest
[31] = (l
>> 8) & 0xff;
1676 digest
[30] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[44]) << 0;
1679 l
|= itoa64_to_int (buf
[45]) << 6;
1680 l
|= itoa64_to_int (buf
[46]) << 12;
1681 l
|= itoa64_to_int (buf
[47]) << 18;
1683 digest
[35] = (l
>> 0) & 0xff;
1684 digest
[34] = (l
>> 8) & 0xff;
1685 digest
[33] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[48]) << 0;
1688 l
|= itoa64_to_int (buf
[49]) << 6;
1689 l
|= itoa64_to_int (buf
[50]) << 12;
1690 l
|= itoa64_to_int (buf
[51]) << 18;
1692 digest
[38] = (l
>> 0) & 0xff;
1693 digest
[37] = (l
>> 8) & 0xff;
1694 digest
[36] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[52]) << 0;
1697 l
|= itoa64_to_int (buf
[53]) << 6;
1698 l
|= itoa64_to_int (buf
[54]) << 12;
1699 l
|= itoa64_to_int (buf
[55]) << 18;
1701 digest
[41] = (l
>> 0) & 0xff;
1702 digest
[40] = (l
>> 8) & 0xff;
1703 digest
[39] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[56]) << 0;
1706 l
|= itoa64_to_int (buf
[57]) << 6;
1707 l
|= itoa64_to_int (buf
[58]) << 12;
1708 l
|= itoa64_to_int (buf
[59]) << 18;
1710 digest
[44] = (l
>> 0) & 0xff;
1711 digest
[43] = (l
>> 8) & 0xff;
1712 digest
[42] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[60]) << 0;
1715 l
|= itoa64_to_int (buf
[61]) << 6;
1716 l
|= itoa64_to_int (buf
[62]) << 12;
1717 l
|= itoa64_to_int (buf
[63]) << 18;
1719 digest
[47] = (l
>> 0) & 0xff;
1720 digest
[46] = (l
>> 8) & 0xff;
1721 digest
[45] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[64]) << 0;
1724 l
|= itoa64_to_int (buf
[65]) << 6;
1725 l
|= itoa64_to_int (buf
[66]) << 12;
1726 l
|= itoa64_to_int (buf
[67]) << 18;
1728 digest
[50] = (l
>> 0) & 0xff;
1729 digest
[49] = (l
>> 8) & 0xff;
1730 digest
[48] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[68]) << 0;
1733 l
|= itoa64_to_int (buf
[69]) << 6;
1734 l
|= itoa64_to_int (buf
[70]) << 12;
1735 l
|= itoa64_to_int (buf
[71]) << 18;
1737 digest
[53] = (l
>> 0) & 0xff;
1738 digest
[52] = (l
>> 8) & 0xff;
1739 digest
[51] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[72]) << 0;
1742 l
|= itoa64_to_int (buf
[73]) << 6;
1743 l
|= itoa64_to_int (buf
[74]) << 12;
1744 l
|= itoa64_to_int (buf
[75]) << 18;
1746 digest
[56] = (l
>> 0) & 0xff;
1747 digest
[55] = (l
>> 8) & 0xff;
1748 digest
[54] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[76]) << 0;
1751 l
|= itoa64_to_int (buf
[77]) << 6;
1752 l
|= itoa64_to_int (buf
[78]) << 12;
1753 l
|= itoa64_to_int (buf
[79]) << 18;
1755 digest
[59] = (l
>> 0) & 0xff;
1756 digest
[58] = (l
>> 8) & 0xff;
1757 digest
[57] = (l
>> 16) & 0xff;
1759 l
= itoa64_to_int (buf
[80]) << 0;
1760 l
|= itoa64_to_int (buf
[81]) << 6;
1761 l
|= itoa64_to_int (buf
[82]) << 12;
1762 l
|= itoa64_to_int (buf
[83]) << 18;
1764 digest
[62] = (l
>> 0) & 0xff;
1765 digest
[61] = (l
>> 8) & 0xff;
1766 digest
[60] = (l
>> 16) & 0xff;
1768 l
= itoa64_to_int (buf
[84]) << 0;
1769 l
|= itoa64_to_int (buf
[85]) << 6;
1771 digest
[63] = (l
>> 16) & 0xff;
1774 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1778 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1780 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1787 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1794 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[11] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1801 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[15] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1808 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[19] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1815 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[23] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1822 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[27] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1829 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[31] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1836 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[35] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1843 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[39] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1850 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[43] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1857 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[47] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1864 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[51] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1871 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[55] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1878 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[59] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1885 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[63] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1892 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[67] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1899 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[71] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1906 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[75] = int_to_itoa64 (l
& 0x3f);
1911 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1913 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1915 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[79] = int_to_itoa64 (l
& 0x3f);
1918 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1920 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1922 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1923 buf
[83] = int_to_itoa64 (l
& 0x3f);
1925 l
= 0 | 0 | (digest
[63] << 16);
1927 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1931 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1935 l
= itoa64_to_int (buf
[ 0]) << 0;
1936 l
|= itoa64_to_int (buf
[ 1]) << 6;
1937 l
|= itoa64_to_int (buf
[ 2]) << 12;
1938 l
|= itoa64_to_int (buf
[ 3]) << 18;
1940 digest
[ 0] = (l
>> 16) & 0xff;
1941 digest
[10] = (l
>> 8) & 0xff;
1942 digest
[20] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[ 4]) << 0;
1945 l
|= itoa64_to_int (buf
[ 5]) << 6;
1946 l
|= itoa64_to_int (buf
[ 6]) << 12;
1947 l
|= itoa64_to_int (buf
[ 7]) << 18;
1949 digest
[21] = (l
>> 16) & 0xff;
1950 digest
[ 1] = (l
>> 8) & 0xff;
1951 digest
[11] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[ 8]) << 0;
1954 l
|= itoa64_to_int (buf
[ 9]) << 6;
1955 l
|= itoa64_to_int (buf
[10]) << 12;
1956 l
|= itoa64_to_int (buf
[11]) << 18;
1958 digest
[12] = (l
>> 16) & 0xff;
1959 digest
[22] = (l
>> 8) & 0xff;
1960 digest
[ 2] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[12]) << 0;
1963 l
|= itoa64_to_int (buf
[13]) << 6;
1964 l
|= itoa64_to_int (buf
[14]) << 12;
1965 l
|= itoa64_to_int (buf
[15]) << 18;
1967 digest
[ 3] = (l
>> 16) & 0xff;
1968 digest
[13] = (l
>> 8) & 0xff;
1969 digest
[23] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[16]) << 0;
1972 l
|= itoa64_to_int (buf
[17]) << 6;
1973 l
|= itoa64_to_int (buf
[18]) << 12;
1974 l
|= itoa64_to_int (buf
[19]) << 18;
1976 digest
[24] = (l
>> 16) & 0xff;
1977 digest
[ 4] = (l
>> 8) & 0xff;
1978 digest
[14] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[20]) << 0;
1981 l
|= itoa64_to_int (buf
[21]) << 6;
1982 l
|= itoa64_to_int (buf
[22]) << 12;
1983 l
|= itoa64_to_int (buf
[23]) << 18;
1985 digest
[15] = (l
>> 16) & 0xff;
1986 digest
[25] = (l
>> 8) & 0xff;
1987 digest
[ 5] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[24]) << 0;
1990 l
|= itoa64_to_int (buf
[25]) << 6;
1991 l
|= itoa64_to_int (buf
[26]) << 12;
1992 l
|= itoa64_to_int (buf
[27]) << 18;
1994 digest
[ 6] = (l
>> 16) & 0xff;
1995 digest
[16] = (l
>> 8) & 0xff;
1996 digest
[26] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[28]) << 0;
1999 l
|= itoa64_to_int (buf
[29]) << 6;
2000 l
|= itoa64_to_int (buf
[30]) << 12;
2001 l
|= itoa64_to_int (buf
[31]) << 18;
2003 digest
[27] = (l
>> 16) & 0xff;
2004 digest
[ 7] = (l
>> 8) & 0xff;
2005 digest
[17] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[32]) << 0;
2008 l
|= itoa64_to_int (buf
[33]) << 6;
2009 l
|= itoa64_to_int (buf
[34]) << 12;
2010 l
|= itoa64_to_int (buf
[35]) << 18;
2012 digest
[18] = (l
>> 16) & 0xff;
2013 digest
[28] = (l
>> 8) & 0xff;
2014 digest
[ 8] = (l
>> 0) & 0xff;
2016 l
= itoa64_to_int (buf
[36]) << 0;
2017 l
|= itoa64_to_int (buf
[37]) << 6;
2018 l
|= itoa64_to_int (buf
[38]) << 12;
2019 l
|= itoa64_to_int (buf
[39]) << 18;
2021 digest
[ 9] = (l
>> 16) & 0xff;
2022 digest
[19] = (l
>> 8) & 0xff;
2023 digest
[29] = (l
>> 0) & 0xff;
2025 l
= itoa64_to_int (buf
[40]) << 0;
2026 l
|= itoa64_to_int (buf
[41]) << 6;
2027 l
|= itoa64_to_int (buf
[42]) << 12;
2029 digest
[31] = (l
>> 8) & 0xff;
2030 digest
[30] = (l
>> 0) & 0xff;
2033 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2037 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2039 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2046 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2053 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2060 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2067 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2074 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2081 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2088 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2095 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2102 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2104 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2107 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2109 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2111 buf
[42] = int_to_itoa64 (l
& 0x3f);
2114 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2118 l
= itoa64_to_int (buf
[ 0]) << 0;
2119 l
|= itoa64_to_int (buf
[ 1]) << 6;
2120 l
|= itoa64_to_int (buf
[ 2]) << 12;
2121 l
|= itoa64_to_int (buf
[ 3]) << 18;
2123 digest
[ 0] = (l
>> 0) & 0xff;
2124 digest
[ 1] = (l
>> 8) & 0xff;
2125 digest
[ 2] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[ 4]) << 0;
2128 l
|= itoa64_to_int (buf
[ 5]) << 6;
2129 l
|= itoa64_to_int (buf
[ 6]) << 12;
2130 l
|= itoa64_to_int (buf
[ 7]) << 18;
2132 digest
[ 3] = (l
>> 0) & 0xff;
2133 digest
[ 4] = (l
>> 8) & 0xff;
2134 digest
[ 5] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[ 8]) << 0;
2137 l
|= itoa64_to_int (buf
[ 9]) << 6;
2138 l
|= itoa64_to_int (buf
[10]) << 12;
2139 l
|= itoa64_to_int (buf
[11]) << 18;
2141 digest
[ 6] = (l
>> 0) & 0xff;
2142 digest
[ 7] = (l
>> 8) & 0xff;
2143 digest
[ 8] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[12]) << 0;
2146 l
|= itoa64_to_int (buf
[13]) << 6;
2147 l
|= itoa64_to_int (buf
[14]) << 12;
2148 l
|= itoa64_to_int (buf
[15]) << 18;
2150 digest
[ 9] = (l
>> 0) & 0xff;
2151 digest
[10] = (l
>> 8) & 0xff;
2152 digest
[11] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[16]) << 0;
2155 l
|= itoa64_to_int (buf
[17]) << 6;
2156 l
|= itoa64_to_int (buf
[18]) << 12;
2157 l
|= itoa64_to_int (buf
[19]) << 18;
2159 digest
[12] = (l
>> 0) & 0xff;
2160 digest
[13] = (l
>> 8) & 0xff;
2161 digest
[14] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[20]) << 0;
2164 l
|= itoa64_to_int (buf
[21]) << 6;
2165 l
|= itoa64_to_int (buf
[22]) << 12;
2166 l
|= itoa64_to_int (buf
[23]) << 18;
2168 digest
[15] = (l
>> 0) & 0xff;
2169 digest
[16] = (l
>> 8) & 0xff;
2170 digest
[17] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[24]) << 0;
2173 l
|= itoa64_to_int (buf
[25]) << 6;
2174 l
|= itoa64_to_int (buf
[26]) << 12;
2175 l
|= itoa64_to_int (buf
[27]) << 18;
2177 digest
[18] = (l
>> 0) & 0xff;
2178 digest
[19] = (l
>> 8) & 0xff;
2179 digest
[20] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[28]) << 0;
2182 l
|= itoa64_to_int (buf
[29]) << 6;
2183 l
|= itoa64_to_int (buf
[30]) << 12;
2184 l
|= itoa64_to_int (buf
[31]) << 18;
2186 digest
[21] = (l
>> 0) & 0xff;
2187 digest
[22] = (l
>> 8) & 0xff;
2188 digest
[23] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[32]) << 0;
2191 l
|= itoa64_to_int (buf
[33]) << 6;
2192 l
|= itoa64_to_int (buf
[34]) << 12;
2193 l
|= itoa64_to_int (buf
[35]) << 18;
2195 digest
[24] = (l
>> 0) & 0xff;
2196 digest
[25] = (l
>> 8) & 0xff;
2197 digest
[26] = (l
>> 16) & 0xff;
2199 l
= itoa64_to_int (buf
[36]) << 0;
2200 l
|= itoa64_to_int (buf
[37]) << 6;
2201 l
|= itoa64_to_int (buf
[38]) << 12;
2202 l
|= itoa64_to_int (buf
[39]) << 18;
2204 digest
[27] = (l
>> 0) & 0xff;
2205 digest
[28] = (l
>> 8) & 0xff;
2206 digest
[29] = (l
>> 16) & 0xff;
2208 l
= itoa64_to_int (buf
[40]) << 0;
2209 l
|= itoa64_to_int (buf
[41]) << 6;
2210 l
|= itoa64_to_int (buf
[42]) << 12;
2211 l
|= itoa64_to_int (buf
[43]) << 18;
2213 digest
[30] = (l
>> 0) & 0xff;
2214 digest
[31] = (l
>> 8) & 0xff;
2215 digest
[32] = (l
>> 16) & 0xff;
2250 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2254 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2256 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2263 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2270 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[11] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2277 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[15] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2284 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[19] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2291 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[23] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2298 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[27] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2305 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[31] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2312 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[35] = int_to_itoa64 (l
& 0x3f);
2317 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2319 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2321 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2322 buf
[39] = int_to_itoa64 (l
& 0x3f);
2324 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2326 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2328 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2329 //buf[43] = int_to_itoa64 (l & 0x3f);
2337 static struct termio savemodes
;
2338 static int havemodes
= 0;
2342 struct termio modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3409 return (clocksThrottleReasons
> 0);
3415 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3417 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3421 if (data
.hm_device
[device_id
].od_version
== 5)
3423 ADLFanSpeedValue lpFanSpeedValue
;
3425 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3427 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3428 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3429 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3430 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3432 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3436 else // od_version == 6
3438 ADLOD6FanSpeedValue fan_speed_value
;
3440 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3442 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3443 fan_speed_value
.iFanSpeed
= fanspeed
;
3445 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3455 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3457 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3461 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3463 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3465 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3466 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3468 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3477 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3479 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3481 if (data
.hm_xnvctrl
)
3483 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3492 #endif // HAVE_HWMON
3498 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3500 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3502 if (css_cnt
> SP_PW_MAX
)
3504 log_error ("ERROR: Mask length is too long");
3509 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3511 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3513 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3514 uint cs_len
= css
[css_pos
].cs_len
;
3516 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3518 uint c
= cs_buf
[cs_pos
] & 0xff;
3525 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3527 cs_t
*cs
= &css
[css_cnt
];
3529 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3531 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3535 for (i
= 0; i
< cs
->cs_len
; i
++)
3537 const uint u
= cs
->cs_buf
[i
];
3542 for (i
= 0; i
< in_len
; i
++)
3544 uint u
= in_buf
[i
] & 0xff;
3546 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3548 if (css_uniq
[u
] == 1) continue;
3552 cs
->cs_buf
[cs
->cs_len
] = u
;
3560 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3564 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3566 uint p0
= in_buf
[in_pos
] & 0xff;
3568 if (interpret
== 1 && p0
== '?')
3572 if (in_pos
== in_len
) break;
3574 uint p1
= in_buf
[in_pos
] & 0xff;
3578 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3580 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3582 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3584 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3586 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3588 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3590 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3591 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3593 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3594 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3596 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3597 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3599 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3600 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3602 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3604 default: log_error ("Syntax error: %s", in_buf
);
3610 if (data
.hex_charset
)
3614 if (in_pos
== in_len
)
3616 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3621 uint p1
= in_buf
[in_pos
] & 0xff;
3623 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3625 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3632 chr
= hex_convert (p1
) << 0;
3633 chr
|= hex_convert (p0
) << 4;
3635 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3641 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3647 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3651 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3653 sum
*= css
[css_pos
].cs_len
;
3659 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3661 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 char p0
= mask_buf
[mask_pos
];
3674 if (mask_pos
== mask_len
) break;
3676 char p1
= mask_buf
[mask_pos
];
3682 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3684 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3686 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3688 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3690 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3692 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3694 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3695 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3697 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3698 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3700 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3701 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3703 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3704 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3706 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3708 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3714 if (data
.hex_charset
)
3718 // if there is no 2nd hex character, show an error:
3720 if (mask_pos
== mask_len
)
3722 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3727 char p1
= mask_buf
[mask_pos
];
3729 // if they are not valid hex character, show an error:
3731 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3733 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3740 chr
|= hex_convert (p1
) << 0;
3741 chr
|= hex_convert (p0
) << 4;
3743 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3749 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3756 log_error ("ERROR: Invalid mask length (0)");
3766 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3768 for (int i
= 0; i
< css_cnt
; i
++)
3770 uint len
= css
[i
].cs_len
;
3771 u64 next
= val
/ len
;
3772 uint pos
= val
% len
;
3773 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3778 void mp_cut_at (char *mask
, uint max
)
3782 uint mask_len
= strlen (mask
);
3784 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3786 if (mask
[i
] == '?') i
++;
3792 void mp_setup_sys (cs_t
*mp_sys
)
3796 uint donec
[CHARSIZ
] = { 0 };
3798 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3799 mp_sys
[0].cs_buf
[pos
++] = chr
;
3800 mp_sys
[0].cs_len
= pos
; }
3802 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3803 mp_sys
[1].cs_buf
[pos
++] = chr
;
3804 mp_sys
[1].cs_len
= pos
; }
3806 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3807 mp_sys
[2].cs_buf
[pos
++] = chr
;
3808 mp_sys
[2].cs_len
= pos
; }
3810 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3811 mp_sys
[3].cs_buf
[pos
++] = chr
;
3812 mp_sys
[3].cs_len
= pos
; }
3814 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3815 mp_sys
[4].cs_len
= pos
; }
3817 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3818 mp_sys
[5].cs_len
= pos
; }
3821 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3823 FILE *fp
= fopen (buf
, "rb");
3825 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3827 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3831 char mp_file
[1024] = { 0 };
3833 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3837 len
= in_superchop (mp_file
);
3841 log_info ("WARNING: Charset file corrupted");
3843 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3847 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3852 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3854 mp_usr
[index
].cs_len
= 0;
3856 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3859 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3861 char *new_mask_buf
= (char *) mymalloc (256);
3867 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3869 if (css_pos
== len
) break;
3871 char p0
= mask_buf
[mask_pos
];
3873 new_mask_buf
[mask_pos
] = p0
;
3879 if (mask_pos
== mask_len
) break;
3881 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3885 if (data
.hex_charset
)
3889 if (mask_pos
== mask_len
)
3891 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3896 char p1
= mask_buf
[mask_pos
];
3898 // if they are not valid hex character, show an error:
3900 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3902 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3907 new_mask_buf
[mask_pos
] = p1
;
3912 if (css_pos
== len
) return (new_mask_buf
);
3914 myfree (new_mask_buf
);
3923 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3929 for (i
= start
; i
< stop
; i
++)
3931 sum
*= root_css_buf
[i
].cs_len
;
3937 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3941 cs_t
*cs
= &root_css_buf
[start
];
3945 for (i
= start
; i
< stop
; i
++)
3947 const u64 m
= v
% cs
->cs_len
;
3948 const u64 d
= v
/ cs
->cs_len
;
3952 const uint k
= cs
->cs_buf
[m
];
3954 pw_buf
[i
- start
] = (char) k
;
3956 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3960 int sp_comp_val (const void *p1
, const void *p2
)
3962 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3963 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3965 return b2
->val
- b1
->val
;
3968 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
)
3975 * Initialize hcstats
3978 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3980 u64
*root_stats_ptr
= root_stats_buf
;
3982 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3984 for (i
= 0; i
< SP_PW_MAX
; i
++)
3986 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3988 root_stats_ptr
+= CHARSIZ
;
3991 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3993 u64
*markov_stats_ptr
= markov_stats_buf
;
3995 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3997 for (i
= 0; i
< SP_PW_MAX
; i
++)
3999 for (j
= 0; j
< CHARSIZ
; j
++)
4001 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4003 markov_stats_ptr
+= CHARSIZ
;
4013 char hcstat_tmp
[256] = { 0 };
4015 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4017 hcstat
= hcstat_tmp
;
4020 FILE *fd
= fopen (hcstat
, "rb");
4024 log_error ("%s: %s", hcstat
, strerror (errno
));
4029 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4031 log_error ("%s: Could not load data", hcstat
);
4038 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4040 log_error ("%s: Could not load data", hcstat
);
4050 * Markov modifier of hcstat_table on user request
4055 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4056 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4061 /* Add all stats to first position */
4063 for (i
= 1; i
< SP_PW_MAX
; i
++)
4065 u64
*out
= root_stats_buf_by_pos
[0];
4066 u64
*in
= root_stats_buf_by_pos
[i
];
4068 for (j
= 0; j
< CHARSIZ
; j
++)
4074 for (i
= 1; i
< SP_PW_MAX
; i
++)
4076 u64
*out
= markov_stats_buf_by_key
[0][0];
4077 u64
*in
= markov_stats_buf_by_key
[i
][0];
4079 for (j
= 0; j
< CHARSIZ
; j
++)
4081 for (k
= 0; k
< CHARSIZ
; k
++)
4088 /* copy them to all pw_positions */
4090 for (i
= 1; i
< SP_PW_MAX
; i
++)
4092 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4095 for (i
= 1; i
< SP_PW_MAX
; i
++)
4097 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4105 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4107 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4109 for (i
= 0; i
< SP_PW_MAX
; i
++)
4111 root_table_buf_by_pos
[i
] = root_table_ptr
;
4113 root_table_ptr
+= CHARSIZ
;
4116 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4118 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4120 for (i
= 0; i
< SP_PW_MAX
; i
++)
4122 for (j
= 0; j
< CHARSIZ
; j
++)
4124 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4126 markov_table_ptr
+= CHARSIZ
;
4131 * Convert hcstat to tables
4134 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4136 uint key
= i
% CHARSIZ
;
4138 root_table_buf
[i
].key
= key
;
4139 root_table_buf
[i
].val
= root_stats_buf
[i
];
4142 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4144 uint key
= i
% CHARSIZ
;
4146 markov_table_buf
[i
].key
= key
;
4147 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4150 myfree (root_stats_buf
);
4151 myfree (markov_stats_buf
);
4157 for (i
= 0; i
< SP_PW_MAX
; i
++)
4159 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4162 for (i
= 0; i
< SP_PW_MAX
; i
++)
4164 for (j
= 0; j
< CHARSIZ
; j
++)
4166 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4171 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
])
4174 * Convert tables to css
4177 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4179 uint pw_pos
= i
/ CHARSIZ
;
4181 cs_t
*cs
= &root_css_buf
[pw_pos
];
4183 if (cs
->cs_len
== threshold
) continue;
4185 uint key
= root_table_buf
[i
].key
;
4187 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4189 cs
->cs_buf
[cs
->cs_len
] = key
;
4195 * Convert table to css
4198 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4200 uint c
= i
/ CHARSIZ
;
4202 cs_t
*cs
= &markov_css_buf
[c
];
4204 if (cs
->cs_len
== threshold
) continue;
4206 uint pw_pos
= c
/ CHARSIZ
;
4208 uint key
= markov_table_buf
[i
].key
;
4210 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4212 cs
->cs_buf
[cs
->cs_len
] = key
;
4218 for (uint i = 0; i < 8; i++)
4220 for (uint j = 0x20; j < 0x80; j++)
4222 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4224 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4226 for (uint k = 0; k < 10; k++)
4228 printf (" %u\n", ptr->cs_buf[k]);
4235 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4237 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4239 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4249 for (uint j
= 1; j
< CHARSIZ
; j
++)
4259 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4261 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4263 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4265 out
+= CHARSIZ
* CHARSIZ
;
4266 in
+= CHARSIZ
* CHARSIZ
;
4268 for (uint j
= 0; j
< CHARSIZ
; j
++)
4275 for (uint k
= 1; k
< CHARSIZ
; k
++)
4287 * mixed shared functions
4290 void dump_hex (const u8
*s
, const int sz
)
4292 for (int i
= 0; i
< sz
; i
++)
4294 log_info_nn ("%02x ", s
[i
]);
4300 void usage_mini_print (const char *progname
)
4302 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4305 void usage_big_print (const char *progname
)
4307 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4310 char *get_exec_path ()
4312 int exec_path_len
= 1024;
4314 char *exec_path
= (char *) mymalloc (exec_path_len
);
4318 char tmp
[32] = { 0 };
4320 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4322 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4326 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4330 uint size
= exec_path_len
;
4332 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4334 log_error("! executable path buffer too small\n");
4339 const int len
= strlen (exec_path
);
4342 #error Your Operating System is not supported or detected
4350 char *get_install_dir (const char *progname
)
4352 char *install_dir
= mystrdup (progname
);
4353 char *last_slash
= NULL
;
4355 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4359 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4365 install_dir
[0] = '.';
4369 return (install_dir
);
4372 char *get_profile_dir (const char *homedir
)
4374 #define DOT_HASHCAT ".hashcat"
4376 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4378 char *profile_dir
= (char *) mymalloc (len
+ 1);
4380 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4385 char *get_session_dir (const char *profile_dir
)
4387 #define SESSIONS_FOLDER "sessions"
4389 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4391 char *session_dir
= (char *) mymalloc (len
+ 1);
4393 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4398 uint
count_lines (FILE *fd
)
4402 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4408 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4410 if (nread
< 1) continue;
4414 for (i
= 0; i
< nread
; i
++)
4416 if (prev
== '\n') cnt
++;
4427 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4431 FILE *fd
= fopen (filename
, "rb");
4435 log_error ("%s: %s", filename
, strerror (errno
));
4440 #define MAX_KEY_SIZE (1024 * 1024)
4442 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4444 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4450 for (int fpos
= 0; fpos
< nread
; fpos
++)
4452 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4454 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4455 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4456 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4457 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4459 if (kpos
>= 64) kpos
= 0;
4466 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4470 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4471 if (CPU_ISSET(core
, cpu_set
)) break;
4473 thread_affinity_policy_data_t policy
= { core
};
4475 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4477 if (data
.quiet
== 0)
4479 if (rc
!= KERN_SUCCESS
)
4481 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4489 void set_cpu_affinity (char *cpu_affinity
)
4492 DWORD_PTR aff_mask
= 0;
4500 char *devices
= strdup (cpu_affinity
);
4502 char *next
= strtok (devices
, ",");
4506 uint cpu_id
= atoi (next
);
4521 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4527 aff_mask
|= 1 << (cpu_id
- 1);
4529 CPU_SET ((cpu_id
- 1), &cpuset
);
4532 } while ((next
= strtok (NULL
, ",")) != NULL
);
4538 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4539 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4541 pthread_t thread
= pthread_self ();
4542 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4546 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4548 char *element
, *end
;
4550 end
= (char *) base
+ nmemb
* size
;
4552 for (element
= (char *) base
; element
< end
; element
+= size
)
4553 if (!compar (element
, key
))
4559 int sort_by_u32 (const void *v1
, const void *v2
)
4561 const u32
*s1
= (const u32
*) v1
;
4562 const u32
*s2
= (const u32
*) v2
;
4567 int sort_by_salt (const void *v1
, const void *v2
)
4569 const salt_t
*s1
= (const salt_t
*) v1
;
4570 const salt_t
*s2
= (const salt_t
*) v2
;
4572 const int res1
= s1
->salt_len
- s2
->salt_len
;
4574 if (res1
!= 0) return (res1
);
4576 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4578 if (res2
!= 0) return (res2
);
4586 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4587 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4594 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4595 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4601 int sort_by_salt_buf (const void *v1
, const void *v2
)
4603 const pot_t
*p1
= (const pot_t
*) v1
;
4604 const pot_t
*p2
= (const pot_t
*) v2
;
4606 const hash_t
*h1
= &p1
->hash
;
4607 const hash_t
*h2
= &p2
->hash
;
4609 const salt_t
*s1
= h1
->salt
;
4610 const salt_t
*s2
= h2
->salt
;
4616 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4617 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4623 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4625 const hash_t
*h1
= (const hash_t
*) v1
;
4626 const hash_t
*h2
= (const hash_t
*) v2
;
4628 const salt_t
*s1
= h1
->salt
;
4629 const salt_t
*s2
= h2
->salt
;
4631 // testphase: this should work
4636 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4637 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4640 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4641 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4642 if (s1->salt_len > s2->salt_len) return ( 1);
4643 if (s1->salt_len < s2->salt_len) return (-1);
4645 uint n = s1->salt_len;
4649 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4650 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4657 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4659 const hash_t
*h1
= (const hash_t
*) v1
;
4660 const hash_t
*h2
= (const hash_t
*) v2
;
4662 const salt_t
*s1
= h1
->salt
;
4663 const salt_t
*s2
= h2
->salt
;
4665 // 16 - 2 (since last 2 uints contain the digest)
4670 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4671 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4677 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4679 const hash_t
*h1
= (const hash_t
*) v1
;
4680 const hash_t
*h2
= (const hash_t
*) v2
;
4682 const void *d1
= h1
->digest
;
4683 const void *d2
= h2
->digest
;
4685 return data
.sort_by_digest (d1
, d2
);
4688 int sort_by_hash (const void *v1
, const void *v2
)
4690 const hash_t
*h1
= (const hash_t
*) v1
;
4691 const hash_t
*h2
= (const hash_t
*) v2
;
4695 const salt_t
*s1
= h1
->salt
;
4696 const salt_t
*s2
= h2
->salt
;
4698 int res
= sort_by_salt (s1
, s2
);
4700 if (res
!= 0) return (res
);
4703 const void *d1
= h1
->digest
;
4704 const void *d2
= h2
->digest
;
4706 return data
.sort_by_digest (d1
, d2
);
4709 int sort_by_pot (const void *v1
, const void *v2
)
4711 const pot_t
*p1
= (const pot_t
*) v1
;
4712 const pot_t
*p2
= (const pot_t
*) v2
;
4714 const hash_t
*h1
= &p1
->hash
;
4715 const hash_t
*h2
= &p2
->hash
;
4717 return sort_by_hash (h1
, h2
);
4720 int sort_by_mtime (const void *p1
, const void *p2
)
4722 const char **f1
= (const char **) p1
;
4723 const char **f2
= (const char **) p2
;
4725 struct stat s1
; stat (*f1
, &s1
);
4726 struct stat s2
; stat (*f2
, &s2
);
4728 return s2
.st_mtime
- s1
.st_mtime
;
4731 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4733 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4734 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4736 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4739 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4741 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4742 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4744 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4747 int sort_by_stringptr (const void *p1
, const void *p2
)
4749 const char **s1
= (const char **) p1
;
4750 const char **s2
= (const char **) p2
;
4752 return strcmp (*s1
, *s2
);
4755 int sort_by_dictstat (const void *s1
, const void *s2
)
4757 dictstat_t
*d1
= (dictstat_t
*) s1
;
4758 dictstat_t
*d2
= (dictstat_t
*) s2
;
4761 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4763 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4766 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4769 int sort_by_bitmap (const void *p1
, const void *p2
)
4771 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4772 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4774 return b1
->collisions
- b2
->collisions
;
4777 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4779 const u32
*d1
= (const u32
*) v1
;
4780 const u32
*d2
= (const u32
*) v2
;
4786 if (d1
[n
] > d2
[n
]) return ( 1);
4787 if (d1
[n
] < d2
[n
]) return (-1);
4793 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4795 const u32
*d1
= (const u32
*) v1
;
4796 const u32
*d2
= (const u32
*) v2
;
4802 if (d1
[n
] > d2
[n
]) return ( 1);
4803 if (d1
[n
] < d2
[n
]) return (-1);
4809 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4811 const u32
*d1
= (const u32
*) v1
;
4812 const u32
*d2
= (const u32
*) v2
;
4818 if (d1
[n
] > d2
[n
]) return ( 1);
4819 if (d1
[n
] < d2
[n
]) return (-1);
4825 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4827 const u32
*d1
= (const u32
*) v1
;
4828 const u32
*d2
= (const u32
*) v2
;
4834 if (d1
[n
] > d2
[n
]) return ( 1);
4835 if (d1
[n
] < d2
[n
]) return (-1);
4841 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4843 const u32
*d1
= (const u32
*) v1
;
4844 const u32
*d2
= (const u32
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4859 const u32
*d1
= (const u32
*) v1
;
4860 const u32
*d2
= (const u32
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4882 if (d1
[n
] > d2
[n
]) return ( 1);
4883 if (d1
[n
] < d2
[n
]) return (-1);
4889 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4891 const u32
*d1
= (const u32
*) v1
;
4892 const u32
*d2
= (const u32
*) v2
;
4898 if (d1
[n
] > d2
[n
]) return ( 1);
4899 if (d1
[n
] < d2
[n
]) return (-1);
4905 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4907 const u64
*d1
= (const u64
*) v1
;
4908 const u64
*d2
= (const u64
*) v2
;
4914 if (d1
[n
] > d2
[n
]) return ( 1);
4915 if (d1
[n
] < d2
[n
]) return (-1);
4921 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4923 const u64
*d1
= (const u64
*) v1
;
4924 const u64
*d2
= (const u64
*) v2
;
4930 if (d1
[n
] > d2
[n
]) return ( 1);
4931 if (d1
[n
] < d2
[n
]) return (-1);
4937 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4939 const u64
*d1
= (const u64
*) v1
;
4940 const u64
*d2
= (const u64
*) v2
;
4946 if (d1
[n
] > d2
[n
]) return ( 1);
4947 if (d1
[n
] < d2
[n
]) return (-1);
4953 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4955 const u32
*d1
= (const u32
*) v1
;
4956 const u32
*d2
= (const u32
*) v2
;
4958 const uint dgst_pos0
= data
.dgst_pos0
;
4959 const uint dgst_pos1
= data
.dgst_pos1
;
4960 const uint dgst_pos2
= data
.dgst_pos2
;
4961 const uint dgst_pos3
= data
.dgst_pos3
;
4963 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4964 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4965 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4966 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4967 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4968 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4969 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4970 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4975 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4977 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4978 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4980 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4982 if (res1
!= 0) return (res1
);
4987 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4989 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4990 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4992 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4994 if (res1
!= 0) return (res1
);
4996 const int res2
= t1
->attack_mode
4999 if (res2
!= 0) return (res2
);
5001 const int res3
= t1
->hash_type
5004 if (res3
!= 0) return (res3
);
5009 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
)
5011 uint outfile_autohex
= data
.outfile_autohex
;
5013 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5015 FILE *debug_fp
= NULL
;
5017 if (debug_file
!= NULL
)
5019 debug_fp
= fopen (debug_file
, "ab");
5021 lock_file (debug_fp
);
5028 if (debug_fp
== NULL
)
5030 log_info ("WARNING: Could not open debug-file for writing");
5034 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5036 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5038 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5041 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5043 if (debug_mode
== 4)
5045 fputc (':', debug_fp
);
5047 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5050 fputc ('\n', debug_fp
);
5052 if (debug_file
!= NULL
) fclose (debug_fp
);
5056 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5058 int needs_hexify
= 0;
5060 if (outfile_autohex
== 1)
5062 for (uint i
= 0; i
< plain_len
; i
++)
5064 if (plain_ptr
[i
] < 0x20)
5071 if (plain_ptr
[i
] > 0x7f)
5080 if (needs_hexify
== 1)
5082 fprintf (fp
, "$HEX[");
5084 for (uint i
= 0; i
< plain_len
; i
++)
5086 fprintf (fp
, "%02x", plain_ptr
[i
]);
5093 fwrite (plain_ptr
, plain_len
, 1, fp
);
5097 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
)
5099 uint outfile_format
= data
.outfile_format
;
5101 char separator
= data
.separator
;
5103 if (outfile_format
& OUTFILE_FMT_HASH
)
5105 fprintf (out_fp
, "%s", out_buf
);
5107 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5109 fputc (separator
, out_fp
);
5112 else if (data
.username
)
5114 if (username
!= NULL
)
5116 for (uint i
= 0; i
< user_len
; i
++)
5118 fprintf (out_fp
, "%c", username
[i
]);
5121 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5123 fputc (separator
, out_fp
);
5128 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5130 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5132 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5134 fputc (separator
, out_fp
);
5138 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5140 for (uint i
= 0; i
< plain_len
; i
++)
5142 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5145 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5147 fputc (separator
, out_fp
);
5151 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5154 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5159 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5161 fprintf (out_fp
, "%llu", crackpos
);
5166 fputc ('\n', out_fp
);
5169 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
)
5173 pot_key
.hash
.salt
= hashes_buf
->salt
;
5174 pot_key
.hash
.digest
= hashes_buf
->digest
;
5176 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5182 input_buf
[input_len
] = 0;
5185 unsigned char *username
= NULL
;
5190 user_t
*user
= hashes_buf
->hash_info
->user
;
5194 username
= (unsigned char *) (user
->user_name
);
5196 user_len
= user
->user_len
;
5200 // do output the line
5201 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5205 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5206 #define LM_MASKED_PLAIN "[notfound]"
5208 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
)
5214 pot_left_key
.hash
.salt
= hash_left
->salt
;
5215 pot_left_key
.hash
.digest
= hash_left
->digest
;
5217 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5221 uint weak_hash_found
= 0;
5223 pot_t pot_right_key
;
5225 pot_right_key
.hash
.salt
= hash_right
->salt
;
5226 pot_right_key
.hash
.digest
= hash_right
->digest
;
5228 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5230 if (pot_right_ptr
== NULL
)
5232 // special case, if "weak hash"
5234 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5236 weak_hash_found
= 1;
5238 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5240 // in theory this is not needed, but we are paranoia:
5242 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5243 pot_right_ptr
->plain_len
= 0;
5247 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5249 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
5254 // at least one half was found:
5258 input_buf
[input_len
] = 0;
5262 unsigned char *username
= NULL
;
5267 user_t
*user
= hash_left
->hash_info
->user
;
5271 username
= (unsigned char *) (user
->user_name
);
5273 user_len
= user
->user_len
;
5277 // mask the part which was not found
5279 uint left_part_masked
= 0;
5280 uint right_part_masked
= 0;
5282 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5284 if (pot_left_ptr
== NULL
)
5286 left_part_masked
= 1;
5288 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5290 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5292 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5293 pot_left_ptr
->plain_len
= mask_plain_len
;
5296 if (pot_right_ptr
== NULL
)
5298 right_part_masked
= 1;
5300 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5302 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5304 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5305 pot_right_ptr
->plain_len
= mask_plain_len
;
5308 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5312 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5314 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5316 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5318 // do output the line
5320 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5322 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5324 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5325 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5328 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
)
5332 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5334 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5336 if (pot_ptr
== NULL
)
5340 input_buf
[input_len
] = 0;
5342 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5346 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
)
5352 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5354 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5358 pot_t pot_right_key
;
5360 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5362 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5364 uint weak_hash_found
= 0;
5366 if (pot_right_ptr
== NULL
)
5368 // special case, if "weak hash"
5370 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5372 weak_hash_found
= 1;
5374 // we just need that pot_right_ptr is not a NULL pointer
5376 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5380 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5382 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5387 // ... at least one part was not cracked
5391 input_buf
[input_len
] = 0;
5393 // only show the hash part which is still not cracked
5395 uint user_len
= input_len
- 32;
5397 char *hash_output
= (char *) mymalloc (33);
5399 memcpy (hash_output
, input_buf
, input_len
);
5401 if (pot_left_ptr
!= NULL
)
5403 // only show right part (because left part was already found)
5405 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5407 hash_output
[user_len
+ 16] = 0;
5410 if (pot_right_ptr
!= NULL
)
5412 // only show left part (because right part was already found)
5414 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5416 hash_output
[user_len
+ 16] = 0;
5419 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5421 myfree (hash_output
);
5423 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5426 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5428 uint opencl_platforms_filter
= 0;
5430 if (opencl_platforms
)
5432 char *platforms
= strdup (opencl_platforms
);
5434 char *next
= strtok (platforms
, ",");
5438 int platform
= atoi (next
);
5440 if (platform
< 1 || platform
> 32)
5442 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5447 opencl_platforms_filter
|= 1 << (platform
- 1);
5449 } while ((next
= strtok (NULL
, ",")) != NULL
);
5455 opencl_platforms_filter
= -1;
5458 return opencl_platforms_filter
;
5461 u32
setup_devices_filter (char *opencl_devices
)
5463 u32 devices_filter
= 0;
5467 char *devices
= strdup (opencl_devices
);
5469 char *next
= strtok (devices
, ",");
5473 int device_id
= atoi (next
);
5475 if (device_id
< 1 || device_id
> 32)
5477 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5482 devices_filter
|= 1 << (device_id
- 1);
5484 } while ((next
= strtok (NULL
, ",")) != NULL
);
5490 devices_filter
= -1;
5493 return devices_filter
;
5496 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5498 cl_device_type device_types_filter
= 0;
5500 if (opencl_device_types
)
5502 char *device_types
= strdup (opencl_device_types
);
5504 char *next
= strtok (device_types
, ",");
5508 int device_type
= atoi (next
);
5510 if (device_type
< 1 || device_type
> 3)
5512 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5517 device_types_filter
|= 1 << device_type
;
5519 } while ((next
= strtok (NULL
, ",")) != NULL
);
5521 free (device_types
);
5525 // Do not use CPU by default, this often reduces GPU performance because
5526 // the CPU is too busy to handle GPU synchronization
5528 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5531 return device_types_filter
;
5534 u32
get_random_num (const u32 min
, const u32 max
)
5536 if (min
== max
) return (min
);
5538 return ((rand () % (max
- min
)) + min
);
5541 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5543 u32 quotient
= dividend
/ divisor
;
5545 if (dividend
% divisor
) quotient
++;
5550 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5552 u64 quotient
= dividend
/ divisor
;
5554 if (dividend
% divisor
) quotient
++;
5559 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5561 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5562 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5564 if (tm
->tm_year
- 70)
5566 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5567 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5569 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5571 else if (tm
->tm_yday
)
5573 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5574 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5576 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5578 else if (tm
->tm_hour
)
5580 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5581 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5583 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5585 else if (tm
->tm_min
)
5587 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5588 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5590 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5594 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5596 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5600 void format_speed_display (float val
, char *buf
, size_t len
)
5611 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5622 /* generate output */
5626 snprintf (buf
, len
- 1, "%.0f ", val
);
5630 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5634 void lowercase (u8
*buf
, int len
)
5636 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5639 void uppercase (u8
*buf
, int len
)
5641 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5644 int fgetl (FILE *fp
, char *line_buf
)
5650 const int c
= fgetc (fp
);
5652 if (c
== EOF
) break;
5654 line_buf
[line_len
] = (char) c
;
5658 if (line_len
== HCBUFSIZ
) line_len
--;
5660 if (c
== '\n') break;
5663 if (line_len
== 0) return 0;
5665 if (line_buf
[line_len
- 1] == '\n')
5669 line_buf
[line_len
] = 0;
5672 if (line_len
== 0) return 0;
5674 if (line_buf
[line_len
- 1] == '\r')
5678 line_buf
[line_len
] = 0;
5684 int in_superchop (char *buf
)
5686 int len
= strlen (buf
);
5690 if (buf
[len
- 1] == '\n')
5697 if (buf
[len
- 1] == '\r')
5712 char **scan_directory (const char *path
)
5714 char *tmp_path
= mystrdup (path
);
5716 size_t tmp_path_len
= strlen (tmp_path
);
5718 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5720 tmp_path
[tmp_path_len
- 1] = 0;
5722 tmp_path_len
= strlen (tmp_path
);
5725 char **files
= NULL
;
5731 if ((d
= opendir (tmp_path
)) != NULL
)
5737 memset (&e
, 0, sizeof (e
));
5738 struct dirent
*de
= NULL
;
5740 if (readdir_r (d
, &e
, &de
) != 0)
5742 log_error ("ERROR: readdir_r() failed");
5747 if (de
== NULL
) break;
5751 while ((de
= readdir (d
)) != NULL
)
5754 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5756 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5758 char *path_file
= (char *) mymalloc (path_size
+ 1);
5760 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5762 path_file
[path_size
] = 0;
5766 if ((d_test
= opendir (path_file
)) != NULL
)
5774 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5778 files
[num_files
- 1] = path_file
;
5784 else if (errno
== ENOTDIR
)
5786 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5790 files
[num_files
- 1] = mystrdup (path
);
5793 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5797 files
[num_files
- 1] = NULL
;
5804 int count_dictionaries (char **dictionary_files
)
5806 if (dictionary_files
== NULL
) return 0;
5810 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5818 char *stroptitype (const uint opti_type
)
5822 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5823 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5824 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5825 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5826 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5827 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5828 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5829 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5830 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5831 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5832 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5833 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5834 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5835 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5836 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5837 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5838 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5839 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5840 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5846 char *strparser (const uint parser_status
)
5848 switch (parser_status
)
5850 case PARSER_OK
: return ((char *) PA_000
); break;
5851 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5852 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5853 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5854 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5855 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5856 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5857 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5858 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5859 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5860 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5861 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5862 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5863 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5864 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5865 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5866 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5869 return ((char *) PA_255
);
5872 char *strhashtype (const uint hash_mode
)
5876 case 0: return ((char *) HT_00000
); break;
5877 case 10: return ((char *) HT_00010
); break;
5878 case 11: return ((char *) HT_00011
); break;
5879 case 12: return ((char *) HT_00012
); break;
5880 case 20: return ((char *) HT_00020
); break;
5881 case 21: return ((char *) HT_00021
); break;
5882 case 22: return ((char *) HT_00022
); break;
5883 case 23: return ((char *) HT_00023
); break;
5884 case 30: return ((char *) HT_00030
); break;
5885 case 40: return ((char *) HT_00040
); break;
5886 case 50: return ((char *) HT_00050
); break;
5887 case 60: return ((char *) HT_00060
); break;
5888 case 100: return ((char *) HT_00100
); break;
5889 case 101: return ((char *) HT_00101
); break;
5890 case 110: return ((char *) HT_00110
); break;
5891 case 111: return ((char *) HT_00111
); break;
5892 case 112: return ((char *) HT_00112
); break;
5893 case 120: return ((char *) HT_00120
); break;
5894 case 121: return ((char *) HT_00121
); break;
5895 case 122: return ((char *) HT_00122
); break;
5896 case 124: return ((char *) HT_00124
); break;
5897 case 125: return ((char *) HT_00125
); break;
5898 case 130: return ((char *) HT_00130
); break;
5899 case 131: return ((char *) HT_00131
); break;
5900 case 132: return ((char *) HT_00132
); break;
5901 case 133: return ((char *) HT_00133
); break;
5902 case 140: return ((char *) HT_00140
); break;
5903 case 141: return ((char *) HT_00141
); break;
5904 case 150: return ((char *) HT_00150
); break;
5905 case 160: return ((char *) HT_00160
); break;
5906 case 200: return ((char *) HT_00200
); break;
5907 case 300: return ((char *) HT_00300
); break;
5908 case 400: return ((char *) HT_00400
); break;
5909 case 500: return ((char *) HT_00500
); break;
5910 case 501: return ((char *) HT_00501
); break;
5911 case 900: return ((char *) HT_00900
); break;
5912 case 910: return ((char *) HT_00910
); break;
5913 case 1000: return ((char *) HT_01000
); break;
5914 case 1100: return ((char *) HT_01100
); break;
5915 case 1400: return ((char *) HT_01400
); break;
5916 case 1410: return ((char *) HT_01410
); break;
5917 case 1420: return ((char *) HT_01420
); break;
5918 case 1421: return ((char *) HT_01421
); break;
5919 case 1430: return ((char *) HT_01430
); break;
5920 case 1440: return ((char *) HT_01440
); break;
5921 case 1441: return ((char *) HT_01441
); break;
5922 case 1450: return ((char *) HT_01450
); break;
5923 case 1460: return ((char *) HT_01460
); break;
5924 case 1500: return ((char *) HT_01500
); break;
5925 case 1600: return ((char *) HT_01600
); break;
5926 case 1700: return ((char *) HT_01700
); break;
5927 case 1710: return ((char *) HT_01710
); break;
5928 case 1711: return ((char *) HT_01711
); break;
5929 case 1720: return ((char *) HT_01720
); break;
5930 case 1722: return ((char *) HT_01722
); break;
5931 case 1730: return ((char *) HT_01730
); break;
5932 case 1731: return ((char *) HT_01731
); break;
5933 case 1740: return ((char *) HT_01740
); break;
5934 case 1750: return ((char *) HT_01750
); break;
5935 case 1760: return ((char *) HT_01760
); break;
5936 case 1800: return ((char *) HT_01800
); break;
5937 case 2100: return ((char *) HT_02100
); break;
5938 case 2400: return ((char *) HT_02400
); break;
5939 case 2410: return ((char *) HT_02410
); break;
5940 case 2500: return ((char *) HT_02500
); break;
5941 case 2600: return ((char *) HT_02600
); break;
5942 case 2611: return ((char *) HT_02611
); break;
5943 case 2612: return ((char *) HT_02612
); break;
5944 case 2711: return ((char *) HT_02711
); break;
5945 case 2811: return ((char *) HT_02811
); break;
5946 case 3000: return ((char *) HT_03000
); break;
5947 case 3100: return ((char *) HT_03100
); break;
5948 case 3200: return ((char *) HT_03200
); break;
5949 case 3710: return ((char *) HT_03710
); break;
5950 case 3711: return ((char *) HT_03711
); break;
5951 case 3800: return ((char *) HT_03800
); break;
5952 case 4300: return ((char *) HT_04300
); break;
5953 case 4400: return ((char *) HT_04400
); break;
5954 case 4500: return ((char *) HT_04500
); break;
5955 case 4700: return ((char *) HT_04700
); break;
5956 case 4800: return ((char *) HT_04800
); break;
5957 case 4900: return ((char *) HT_04900
); break;
5958 case 5000: return ((char *) HT_05000
); break;
5959 case 5100: return ((char *) HT_05100
); break;
5960 case 5200: return ((char *) HT_05200
); break;
5961 case 5300: return ((char *) HT_05300
); break;
5962 case 5400: return ((char *) HT_05400
); break;
5963 case 5500: return ((char *) HT_05500
); break;
5964 case 5600: return ((char *) HT_05600
); break;
5965 case 5700: return ((char *) HT_05700
); break;
5966 case 5800: return ((char *) HT_05800
); break;
5967 case 6000: return ((char *) HT_06000
); break;
5968 case 6100: return ((char *) HT_06100
); break;
5969 case 6211: return ((char *) HT_06211
); break;
5970 case 6212: return ((char *) HT_06212
); break;
5971 case 6213: return ((char *) HT_06213
); break;
5972 case 6221: return ((char *) HT_06221
); break;
5973 case 6222: return ((char *) HT_06222
); break;
5974 case 6223: return ((char *) HT_06223
); break;
5975 case 6231: return ((char *) HT_06231
); break;
5976 case 6232: return ((char *) HT_06232
); break;
5977 case 6233: return ((char *) HT_06233
); break;
5978 case 6241: return ((char *) HT_06241
); break;
5979 case 6242: return ((char *) HT_06242
); break;
5980 case 6243: return ((char *) HT_06243
); break;
5981 case 6300: return ((char *) HT_06300
); break;
5982 case 6400: return ((char *) HT_06400
); break;
5983 case 6500: return ((char *) HT_06500
); break;
5984 case 6600: return ((char *) HT_06600
); break;
5985 case 6700: return ((char *) HT_06700
); break;
5986 case 6800: return ((char *) HT_06800
); break;
5987 case 6900: return ((char *) HT_06900
); break;
5988 case 7100: return ((char *) HT_07100
); break;
5989 case 7200: return ((char *) HT_07200
); break;
5990 case 7300: return ((char *) HT_07300
); break;
5991 case 7400: return ((char *) HT_07400
); break;
5992 case 7500: return ((char *) HT_07500
); break;
5993 case 7600: return ((char *) HT_07600
); break;
5994 case 7700: return ((char *) HT_07700
); break;
5995 case 7800: return ((char *) HT_07800
); break;
5996 case 7900: return ((char *) HT_07900
); break;
5997 case 8000: return ((char *) HT_08000
); break;
5998 case 8100: return ((char *) HT_08100
); break;
5999 case 8200: return ((char *) HT_08200
); break;
6000 case 8300: return ((char *) HT_08300
); break;
6001 case 8400: return ((char *) HT_08400
); break;
6002 case 8500: return ((char *) HT_08500
); break;
6003 case 8600: return ((char *) HT_08600
); break;
6004 case 8700: return ((char *) HT_08700
); break;
6005 case 8800: return ((char *) HT_08800
); break;
6006 case 8900: return ((char *) HT_08900
); break;
6007 case 9000: return ((char *) HT_09000
); break;
6008 case 9100: return ((char *) HT_09100
); break;
6009 case 9200: return ((char *) HT_09200
); break;
6010 case 9300: return ((char *) HT_09300
); break;
6011 case 9400: return ((char *) HT_09400
); break;
6012 case 9500: return ((char *) HT_09500
); break;
6013 case 9600: return ((char *) HT_09600
); break;
6014 case 9700: return ((char *) HT_09700
); break;
6015 case 9710: return ((char *) HT_09710
); break;
6016 case 9720: return ((char *) HT_09720
); break;
6017 case 9800: return ((char *) HT_09800
); break;
6018 case 9810: return ((char *) HT_09810
); break;
6019 case 9820: return ((char *) HT_09820
); break;
6020 case 9900: return ((char *) HT_09900
); break;
6021 case 10000: return ((char *) HT_10000
); break;
6022 case 10100: return ((char *) HT_10100
); break;
6023 case 10200: return ((char *) HT_10200
); break;
6024 case 10300: return ((char *) HT_10300
); break;
6025 case 10400: return ((char *) HT_10400
); break;
6026 case 10410: return ((char *) HT_10410
); break;
6027 case 10420: return ((char *) HT_10420
); break;
6028 case 10500: return ((char *) HT_10500
); break;
6029 case 10600: return ((char *) HT_10600
); break;
6030 case 10700: return ((char *) HT_10700
); break;
6031 case 10800: return ((char *) HT_10800
); break;
6032 case 10900: return ((char *) HT_10900
); break;
6033 case 11000: return ((char *) HT_11000
); break;
6034 case 11100: return ((char *) HT_11100
); break;
6035 case 11200: return ((char *) HT_11200
); break;
6036 case 11300: return ((char *) HT_11300
); break;
6037 case 11400: return ((char *) HT_11400
); break;
6038 case 11500: return ((char *) HT_11500
); break;
6039 case 11600: return ((char *) HT_11600
); break;
6040 case 11700: return ((char *) HT_11700
); break;
6041 case 11800: return ((char *) HT_11800
); break;
6042 case 11900: return ((char *) HT_11900
); break;
6043 case 12000: return ((char *) HT_12000
); break;
6044 case 12100: return ((char *) HT_12100
); break;
6045 case 12200: return ((char *) HT_12200
); break;
6046 case 12300: return ((char *) HT_12300
); break;
6047 case 12400: return ((char *) HT_12400
); break;
6048 case 12500: return ((char *) HT_12500
); break;
6049 case 12600: return ((char *) HT_12600
); break;
6050 case 12700: return ((char *) HT_12700
); break;
6051 case 12800: return ((char *) HT_12800
); break;
6052 case 12900: return ((char *) HT_12900
); break;
6053 case 13000: return ((char *) HT_13000
); break;
6054 case 13100: return ((char *) HT_13100
); break;
6055 case 13200: return ((char *) HT_13200
); break;
6056 case 13300: return ((char *) HT_13300
); break;
6057 case 13400: return ((char *) HT_13400
); break;
6058 case 13500: return ((char *) HT_13500
); break;
6059 case 13600: return ((char *) HT_13600
); break;
6060 case 13711: return ((char *) HT_13711
); break;
6061 case 13712: return ((char *) HT_13712
); break;
6062 case 13713: return ((char *) HT_13713
); break;
6063 case 13721: return ((char *) HT_13721
); break;
6064 case 13722: return ((char *) HT_13722
); break;
6065 case 13723: return ((char *) HT_13723
); break;
6066 case 13731: return ((char *) HT_13731
); break;
6067 case 13732: return ((char *) HT_13732
); break;
6068 case 13733: return ((char *) HT_13733
); break;
6069 case 13741: return ((char *) HT_13741
); break;
6070 case 13742: return ((char *) HT_13742
); break;
6071 case 13743: return ((char *) HT_13743
); break;
6072 case 13751: return ((char *) HT_13751
); break;
6073 case 13752: return ((char *) HT_13752
); break;
6074 case 13753: return ((char *) HT_13753
); break;
6075 case 13761: return ((char *) HT_13761
); break;
6076 case 13762: return ((char *) HT_13762
); break;
6077 case 13763: return ((char *) HT_13763
); break;
6078 case 13800: return ((char *) HT_13800
); break;
6081 return ((char *) "Unknown");
6084 char *strstatus (const uint devices_status
)
6086 switch (devices_status
)
6088 case STATUS_INIT
: return ((char *) ST_0000
); break;
6089 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6090 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6091 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6092 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6093 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6094 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6095 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6096 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6097 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6098 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6101 return ((char *) "Unknown");
6104 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6106 uint hash_type
= data
.hash_type
;
6107 uint hash_mode
= data
.hash_mode
;
6108 uint salt_type
= data
.salt_type
;
6109 uint opts_type
= data
.opts_type
;
6110 uint opti_type
= data
.opti_type
;
6111 uint dgst_size
= data
.dgst_size
;
6113 char *hashfile
= data
.hashfile
;
6117 uint digest_buf
[64] = { 0 };
6119 u64
*digest_buf64
= (u64
*) digest_buf
;
6121 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6123 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6125 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6131 case HASH_TYPE_DESCRYPT
:
6132 FP (digest_buf
[1], digest_buf
[0], tt
);
6135 case HASH_TYPE_DESRACF
:
6136 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6137 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6139 FP (digest_buf
[1], digest_buf
[0], tt
);
6143 FP (digest_buf
[1], digest_buf
[0], tt
);
6146 case HASH_TYPE_NETNTLM
:
6147 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6148 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6149 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6150 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6152 FP (digest_buf
[1], digest_buf
[0], tt
);
6153 FP (digest_buf
[3], digest_buf
[2], tt
);
6156 case HASH_TYPE_BSDICRYPT
:
6157 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6158 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6160 FP (digest_buf
[1], digest_buf
[0], tt
);
6165 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6170 digest_buf
[0] += MD4M_A
;
6171 digest_buf
[1] += MD4M_B
;
6172 digest_buf
[2] += MD4M_C
;
6173 digest_buf
[3] += MD4M_D
;
6177 digest_buf
[0] += MD5M_A
;
6178 digest_buf
[1] += MD5M_B
;
6179 digest_buf
[2] += MD5M_C
;
6180 digest_buf
[3] += MD5M_D
;
6183 case HASH_TYPE_SHA1
:
6184 digest_buf
[0] += SHA1M_A
;
6185 digest_buf
[1] += SHA1M_B
;
6186 digest_buf
[2] += SHA1M_C
;
6187 digest_buf
[3] += SHA1M_D
;
6188 digest_buf
[4] += SHA1M_E
;
6191 case HASH_TYPE_SHA256
:
6192 digest_buf
[0] += SHA256M_A
;
6193 digest_buf
[1] += SHA256M_B
;
6194 digest_buf
[2] += SHA256M_C
;
6195 digest_buf
[3] += SHA256M_D
;
6196 digest_buf
[4] += SHA256M_E
;
6197 digest_buf
[5] += SHA256M_F
;
6198 digest_buf
[6] += SHA256M_G
;
6199 digest_buf
[7] += SHA256M_H
;
6202 case HASH_TYPE_SHA384
:
6203 digest_buf64
[0] += SHA384M_A
;
6204 digest_buf64
[1] += SHA384M_B
;
6205 digest_buf64
[2] += SHA384M_C
;
6206 digest_buf64
[3] += SHA384M_D
;
6207 digest_buf64
[4] += SHA384M_E
;
6208 digest_buf64
[5] += SHA384M_F
;
6209 digest_buf64
[6] += 0;
6210 digest_buf64
[7] += 0;
6213 case HASH_TYPE_SHA512
:
6214 digest_buf64
[0] += SHA512M_A
;
6215 digest_buf64
[1] += SHA512M_B
;
6216 digest_buf64
[2] += SHA512M_C
;
6217 digest_buf64
[3] += SHA512M_D
;
6218 digest_buf64
[4] += SHA512M_E
;
6219 digest_buf64
[5] += SHA512M_F
;
6220 digest_buf64
[6] += SHA512M_G
;
6221 digest_buf64
[7] += SHA512M_H
;
6226 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6228 if (dgst_size
== DGST_SIZE_4_2
)
6230 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6232 else if (dgst_size
== DGST_SIZE_4_4
)
6234 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6236 else if (dgst_size
== DGST_SIZE_4_5
)
6238 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6240 else if (dgst_size
== DGST_SIZE_4_6
)
6242 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6244 else if (dgst_size
== DGST_SIZE_4_8
)
6246 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6248 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6250 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6252 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6254 else if (hash_type
== HASH_TYPE_SHA384
)
6256 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6258 else if (hash_type
== HASH_TYPE_SHA512
)
6260 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6262 else if (hash_type
== HASH_TYPE_GOST
)
6264 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6267 else if (dgst_size
== DGST_SIZE_4_64
)
6269 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6271 else if (dgst_size
== DGST_SIZE_8_25
)
6273 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6277 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6278 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6279 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6285 memset (&salt
, 0, sizeof (salt_t
));
6287 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6289 char *ptr
= (char *) salt
.salt_buf
;
6291 uint len
= salt
.salt_len
;
6293 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6299 case HASH_TYPE_NETNTLM
:
6301 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6302 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6304 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6310 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6312 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6320 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6322 uint max
= salt
.salt_len
/ 4;
6326 for (uint i
= 0; i
< max
; i
++)
6328 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6332 if (opts_type
& OPTS_TYPE_ST_HEX
)
6334 char tmp
[64] = { 0 };
6336 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6338 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6343 memcpy (ptr
, tmp
, len
);
6346 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6348 memset (ptr
+ len
, 0, memset_size
);
6350 salt
.salt_len
= len
;
6354 // some modes require special encoding
6357 uint out_buf_plain
[256] = { 0 };
6358 uint out_buf_salt
[256] = { 0 };
6360 char tmp_buf
[1024] = { 0 };
6362 char *ptr_plain
= (char *) out_buf_plain
;
6363 char *ptr_salt
= (char *) out_buf_salt
;
6365 if (hash_mode
== 22)
6367 char username
[30] = { 0 };
6369 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6371 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6373 u16
*ptr
= (u16
*) digest_buf
;
6375 tmp_buf
[ 0] = sig
[0];
6376 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6377 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6378 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6379 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6380 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6381 tmp_buf
[ 6] = sig
[1];
6382 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6383 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6384 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6385 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6386 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6387 tmp_buf
[12] = sig
[2];
6388 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6389 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6390 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6391 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6392 tmp_buf
[17] = sig
[3];
6393 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6394 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6395 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6396 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6397 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6398 tmp_buf
[23] = sig
[4];
6399 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6400 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6401 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6402 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6403 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6404 tmp_buf
[29] = sig
[5];
6406 snprintf (out_buf
, len
-1, "%s:%s",
6410 else if (hash_mode
== 23)
6412 // do not show the skyper part in output
6414 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6416 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6418 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6425 else if (hash_mode
== 101)
6427 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6429 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6430 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6431 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6432 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6433 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6435 memcpy (tmp_buf
, digest_buf
, 20);
6437 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6439 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6441 else if (hash_mode
== 111)
6443 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6445 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6446 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6447 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6448 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6449 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6451 memcpy (tmp_buf
, digest_buf
, 20);
6452 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6454 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6456 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6458 else if ((hash_mode
== 122) || (hash_mode
== 125))
6460 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6461 (char *) salt
.salt_buf
,
6468 else if (hash_mode
== 124)
6470 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6471 (char *) salt
.salt_buf
,
6478 else if (hash_mode
== 131)
6480 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6481 (char *) salt
.salt_buf
,
6489 else if (hash_mode
== 132)
6491 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6492 (char *) salt
.salt_buf
,
6499 else if (hash_mode
== 133)
6501 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6503 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6504 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6505 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6506 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6507 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6509 memcpy (tmp_buf
, digest_buf
, 20);
6511 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6513 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6515 else if (hash_mode
== 141)
6517 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6519 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6521 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6523 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6525 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6526 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6527 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6528 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6529 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6531 memcpy (tmp_buf
, digest_buf
, 20);
6533 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6537 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6539 else if (hash_mode
== 400)
6541 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6543 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6544 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6545 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6546 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6548 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6550 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6552 else if (hash_mode
== 500)
6554 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6556 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6557 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6558 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6559 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6561 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6563 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6565 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6569 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6572 else if (hash_mode
== 501)
6574 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6576 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6577 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6579 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6581 else if (hash_mode
== 1421)
6583 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6585 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6601 else if (hash_mode
== 1441)
6603 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6605 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6607 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6609 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6611 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6612 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6613 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6614 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6615 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6616 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6617 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6618 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6620 memcpy (tmp_buf
, digest_buf
, 32);
6622 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6626 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6628 else if (hash_mode
== 1500)
6630 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6631 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6632 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6633 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6634 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6636 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6638 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6640 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6641 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6643 memcpy (tmp_buf
, digest_buf
, 8);
6645 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6647 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6651 else if (hash_mode
== 1600)
6653 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6655 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6656 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6657 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6658 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6660 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6662 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6664 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6668 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6671 else if (hash_mode
== 1711)
6673 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6675 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6676 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6677 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6678 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6679 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6680 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6681 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6682 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6684 memcpy (tmp_buf
, digest_buf
, 64);
6685 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6687 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6689 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6691 else if (hash_mode
== 1722)
6693 uint
*ptr
= digest_buf
;
6695 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6696 (unsigned char *) salt
.salt_buf
,
6706 else if (hash_mode
== 1731)
6708 uint
*ptr
= digest_buf
;
6710 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6711 (unsigned char *) salt
.salt_buf
,
6721 else if (hash_mode
== 1800)
6725 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6726 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6727 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6728 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6729 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6730 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6731 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6732 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6734 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6736 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6738 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6742 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6745 else if (hash_mode
== 2100)
6749 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6751 salt
.salt_iter
+ 1);
6753 uint signature_len
= strlen (out_buf
);
6755 pos
+= signature_len
;
6756 len
-= signature_len
;
6758 char *salt_ptr
= (char *) salt
.salt_buf
;
6760 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6762 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6763 byte_swap_32 (digest_buf
[0]),
6764 byte_swap_32 (digest_buf
[1]),
6765 byte_swap_32 (digest_buf
[2]),
6766 byte_swap_32 (digest_buf
[3]));
6768 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6770 memcpy (tmp_buf
, digest_buf
, 16);
6772 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6774 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6775 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6776 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6777 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6779 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6780 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6781 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6782 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6784 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6785 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6786 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6787 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6789 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6790 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6791 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6792 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6794 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6795 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6796 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6797 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6801 else if (hash_mode
== 2500)
6803 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6805 wpa_t
*wpa
= &wpas
[salt_pos
];
6807 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6808 (char *) salt
.salt_buf
,
6822 else if (hash_mode
== 4400)
6824 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6825 byte_swap_32 (digest_buf
[0]),
6826 byte_swap_32 (digest_buf
[1]),
6827 byte_swap_32 (digest_buf
[2]),
6828 byte_swap_32 (digest_buf
[3]));
6830 else if (hash_mode
== 4700)
6832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6833 byte_swap_32 (digest_buf
[0]),
6834 byte_swap_32 (digest_buf
[1]),
6835 byte_swap_32 (digest_buf
[2]),
6836 byte_swap_32 (digest_buf
[3]),
6837 byte_swap_32 (digest_buf
[4]));
6839 else if (hash_mode
== 4800)
6841 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6843 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6848 byte_swap_32 (salt
.salt_buf
[0]),
6849 byte_swap_32 (salt
.salt_buf
[1]),
6850 byte_swap_32 (salt
.salt_buf
[2]),
6851 byte_swap_32 (salt
.salt_buf
[3]),
6854 else if (hash_mode
== 4900)
6856 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6857 byte_swap_32 (digest_buf
[0]),
6858 byte_swap_32 (digest_buf
[1]),
6859 byte_swap_32 (digest_buf
[2]),
6860 byte_swap_32 (digest_buf
[3]),
6861 byte_swap_32 (digest_buf
[4]));
6863 else if (hash_mode
== 5100)
6865 snprintf (out_buf
, len
-1, "%08x%08x",
6869 else if (hash_mode
== 5200)
6871 snprintf (out_buf
, len
-1, "%s", hashfile
);
6873 else if (hash_mode
== 5300)
6875 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6877 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6879 int buf_len
= len
-1;
6883 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6885 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6887 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6889 snprintf (out_buf
, buf_len
, ":");
6895 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6903 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6905 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6907 if ((i
== 0) || (i
== 5))
6909 snprintf (out_buf
, buf_len
, ":");
6915 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6923 for (uint i
= 0; i
< 4; i
++)
6927 snprintf (out_buf
, buf_len
, ":");
6933 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6939 else if (hash_mode
== 5400)
6941 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6943 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6945 int buf_len
= len
-1;
6949 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6951 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6953 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6955 snprintf (out_buf
, buf_len
, ":");
6961 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6969 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6971 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6973 if ((i
== 0) || (i
== 5))
6975 snprintf (out_buf
, buf_len
, ":");
6981 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6989 for (uint i
= 0; i
< 5; i
++)
6993 snprintf (out_buf
, buf_len
, ":");
6999 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7005 else if (hash_mode
== 5500)
7007 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7009 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7011 char user_buf
[64] = { 0 };
7012 char domain_buf
[64] = { 0 };
7013 char srvchall_buf
[1024] = { 0 };
7014 char clichall_buf
[1024] = { 0 };
7016 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7018 char *ptr
= (char *) netntlm
->userdomain_buf
;
7020 user_buf
[i
] = ptr
[j
];
7023 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7025 char *ptr
= (char *) netntlm
->userdomain_buf
;
7027 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7030 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7032 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7034 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7037 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7039 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7041 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7044 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7052 byte_swap_32 (salt
.salt_buf_pc
[0]),
7053 byte_swap_32 (salt
.salt_buf_pc
[1]),
7056 else if (hash_mode
== 5600)
7058 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7060 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7062 char user_buf
[64] = { 0 };
7063 char domain_buf
[64] = { 0 };
7064 char srvchall_buf
[1024] = { 0 };
7065 char clichall_buf
[1024] = { 0 };
7067 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7069 char *ptr
= (char *) netntlm
->userdomain_buf
;
7071 user_buf
[i
] = ptr
[j
];
7074 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7076 char *ptr
= (char *) netntlm
->userdomain_buf
;
7078 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7081 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7083 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7085 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7088 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7090 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7092 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7095 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7105 else if (hash_mode
== 5700)
7107 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7109 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7110 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7111 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7112 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7113 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7114 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7115 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7116 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7118 memcpy (tmp_buf
, digest_buf
, 32);
7120 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7124 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7126 else if (hash_mode
== 5800)
7128 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7129 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7130 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7131 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7132 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7134 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7141 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7143 snprintf (out_buf
, len
-1, "%s", hashfile
);
7145 else if (hash_mode
== 6300)
7147 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7149 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7150 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7151 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7152 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7154 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7156 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7158 else if (hash_mode
== 6400)
7160 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7162 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7164 else if (hash_mode
== 6500)
7166 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7168 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7170 else if (hash_mode
== 6600)
7172 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7174 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7176 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7177 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7179 uint buf_len
= len
- 1;
7181 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7184 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7186 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7191 else if (hash_mode
== 6700)
7193 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7195 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7197 else if (hash_mode
== 6800)
7199 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7201 else if (hash_mode
== 7100)
7203 uint
*ptr
= digest_buf
;
7205 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7207 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7209 uint esalt
[8] = { 0 };
7211 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7212 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7213 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7214 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7215 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7216 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7217 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7218 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7220 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",
7221 SIGNATURE_SHA512OSX
,
7223 esalt
[ 0], esalt
[ 1],
7224 esalt
[ 2], esalt
[ 3],
7225 esalt
[ 4], esalt
[ 5],
7226 esalt
[ 6], esalt
[ 7],
7234 ptr
[15], ptr
[14]);
7236 else if (hash_mode
== 7200)
7238 uint
*ptr
= digest_buf
;
7240 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7242 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7246 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7248 len_used
= strlen (out_buf
);
7250 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7252 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7254 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7257 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",
7265 ptr
[15], ptr
[14]);
7267 else if (hash_mode
== 7300)
7269 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7271 rakp_t
*rakp
= &rakps
[salt_pos
];
7273 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7275 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7278 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7285 else if (hash_mode
== 7400)
7287 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7289 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7290 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7291 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7292 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7293 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7294 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7295 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7296 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7298 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7300 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7302 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7306 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7309 else if (hash_mode
== 7500)
7311 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7313 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7315 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7316 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7318 char data
[128] = { 0 };
7320 char *ptr_data
= data
;
7322 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7324 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7327 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7329 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7334 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7336 (char *) krb5pa
->user
,
7337 (char *) krb5pa
->realm
,
7338 (char *) krb5pa
->salt
,
7341 else if (hash_mode
== 7700)
7343 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7344 (char *) salt
.salt_buf
,
7348 else if (hash_mode
== 7800)
7350 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7351 (char *) salt
.salt_buf
,
7358 else if (hash_mode
== 7900)
7360 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7364 char *tmp
= (char *) salt
.salt_buf_pc
;
7366 ptr_plain
[42] = tmp
[0];
7372 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7374 else if (hash_mode
== 8000)
7376 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7377 (unsigned char *) salt
.salt_buf
,
7387 else if (hash_mode
== 8100)
7389 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7390 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7392 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7393 (unsigned char *) salt
.salt_buf
,
7400 else if (hash_mode
== 8200)
7402 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7404 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7406 char data_buf
[4096] = { 0 };
7408 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7410 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7413 data_buf
[cloudkey
->data_len
* 2] = 0;
7415 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7416 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7417 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7418 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7419 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7420 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7421 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7422 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7424 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7425 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7426 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7427 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7429 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7445 else if (hash_mode
== 8300)
7447 char digest_buf_c
[34] = { 0 };
7449 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7450 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7451 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7452 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7453 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7455 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7457 digest_buf_c
[32] = 0;
7461 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7463 char domain_buf_c
[33] = { 0 };
7465 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7467 for (uint i
= 0; i
< salt_pc_len
; i
++)
7469 const char next
= domain_buf_c
[i
];
7471 domain_buf_c
[i
] = '.';
7476 domain_buf_c
[salt_pc_len
] = 0;
7480 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7482 else if (hash_mode
== 8500)
7484 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7486 else if (hash_mode
== 2612)
7488 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7490 (char *) salt
.salt_buf
,
7496 else if (hash_mode
== 3711)
7498 char *salt_ptr
= (char *) salt
.salt_buf
;
7500 salt_ptr
[salt
.salt_len
- 1] = 0;
7502 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7503 SIGNATURE_MEDIAWIKI_B
,
7510 else if (hash_mode
== 8800)
7512 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7514 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7516 char tmp
[3073] = { 0 };
7518 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7520 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7525 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7526 SIGNATURE_ANDROIDFDE
,
7527 byte_swap_32 (salt
.salt_buf
[0]),
7528 byte_swap_32 (salt
.salt_buf
[1]),
7529 byte_swap_32 (salt
.salt_buf
[2]),
7530 byte_swap_32 (salt
.salt_buf
[3]),
7531 byte_swap_32 (digest_buf
[0]),
7532 byte_swap_32 (digest_buf
[1]),
7533 byte_swap_32 (digest_buf
[2]),
7534 byte_swap_32 (digest_buf
[3]),
7537 else if (hash_mode
== 8900)
7539 uint N
= salt
.scrypt_N
;
7540 uint r
= salt
.scrypt_r
;
7541 uint p
= salt
.scrypt_p
;
7543 char base64_salt
[32] = { 0 };
7545 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7547 memset (tmp_buf
, 0, 46);
7549 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7550 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7551 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7552 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7553 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7554 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7555 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7556 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7557 digest_buf
[8] = 0; // needed for base64_encode ()
7559 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7561 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7569 else if (hash_mode
== 9000)
7571 snprintf (out_buf
, len
-1, "%s", hashfile
);
7573 else if (hash_mode
== 9200)
7577 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7579 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7581 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7585 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7586 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7587 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7588 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7589 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7590 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7591 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7592 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7593 digest_buf
[8] = 0; // needed for base64_encode ()
7595 char tmp_buf
[64] = { 0 };
7597 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7598 tmp_buf
[43] = 0; // cut it here
7602 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7604 else if (hash_mode
== 9300)
7606 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7607 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7608 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7609 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7610 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7611 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7612 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7613 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7614 digest_buf
[8] = 0; // needed for base64_encode ()
7616 char tmp_buf
[64] = { 0 };
7618 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7619 tmp_buf
[43] = 0; // cut it here
7621 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7623 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7625 else if (hash_mode
== 9400)
7627 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7629 office2007_t
*office2007
= &office2007s
[salt_pos
];
7631 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7632 SIGNATURE_OFFICE2007
,
7635 office2007
->keySize
,
7641 office2007
->encryptedVerifier
[0],
7642 office2007
->encryptedVerifier
[1],
7643 office2007
->encryptedVerifier
[2],
7644 office2007
->encryptedVerifier
[3],
7645 office2007
->encryptedVerifierHash
[0],
7646 office2007
->encryptedVerifierHash
[1],
7647 office2007
->encryptedVerifierHash
[2],
7648 office2007
->encryptedVerifierHash
[3],
7649 office2007
->encryptedVerifierHash
[4]);
7651 else if (hash_mode
== 9500)
7653 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7655 office2010_t
*office2010
= &office2010s
[salt_pos
];
7657 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,
7663 office2010
->encryptedVerifier
[0],
7664 office2010
->encryptedVerifier
[1],
7665 office2010
->encryptedVerifier
[2],
7666 office2010
->encryptedVerifier
[3],
7667 office2010
->encryptedVerifierHash
[0],
7668 office2010
->encryptedVerifierHash
[1],
7669 office2010
->encryptedVerifierHash
[2],
7670 office2010
->encryptedVerifierHash
[3],
7671 office2010
->encryptedVerifierHash
[4],
7672 office2010
->encryptedVerifierHash
[5],
7673 office2010
->encryptedVerifierHash
[6],
7674 office2010
->encryptedVerifierHash
[7]);
7676 else if (hash_mode
== 9600)
7678 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7680 office2013_t
*office2013
= &office2013s
[salt_pos
];
7682 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,
7688 office2013
->encryptedVerifier
[0],
7689 office2013
->encryptedVerifier
[1],
7690 office2013
->encryptedVerifier
[2],
7691 office2013
->encryptedVerifier
[3],
7692 office2013
->encryptedVerifierHash
[0],
7693 office2013
->encryptedVerifierHash
[1],
7694 office2013
->encryptedVerifierHash
[2],
7695 office2013
->encryptedVerifierHash
[3],
7696 office2013
->encryptedVerifierHash
[4],
7697 office2013
->encryptedVerifierHash
[5],
7698 office2013
->encryptedVerifierHash
[6],
7699 office2013
->encryptedVerifierHash
[7]);
7701 else if (hash_mode
== 9700)
7703 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7705 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7707 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7708 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7709 byte_swap_32 (salt
.salt_buf
[0]),
7710 byte_swap_32 (salt
.salt_buf
[1]),
7711 byte_swap_32 (salt
.salt_buf
[2]),
7712 byte_swap_32 (salt
.salt_buf
[3]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7722 else if (hash_mode
== 9710)
7724 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7726 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7728 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7729 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7730 byte_swap_32 (salt
.salt_buf
[0]),
7731 byte_swap_32 (salt
.salt_buf
[1]),
7732 byte_swap_32 (salt
.salt_buf
[2]),
7733 byte_swap_32 (salt
.salt_buf
[3]),
7734 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7735 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7736 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7737 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7738 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7739 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7743 else if (hash_mode
== 9720)
7745 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7747 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7749 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7751 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7752 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7753 byte_swap_32 (salt
.salt_buf
[0]),
7754 byte_swap_32 (salt
.salt_buf
[1]),
7755 byte_swap_32 (salt
.salt_buf
[2]),
7756 byte_swap_32 (salt
.salt_buf
[3]),
7757 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7758 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7759 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7760 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7761 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7762 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7771 else if (hash_mode
== 9800)
7773 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7775 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7777 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7778 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7783 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7793 else if (hash_mode
== 9810)
7795 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7797 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7799 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7800 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7805 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7806 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7807 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7808 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7809 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7810 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7811 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7815 else if (hash_mode
== 9820)
7817 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7819 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7821 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7823 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7824 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7829 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7830 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7831 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7832 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7833 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7844 else if (hash_mode
== 10000)
7848 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7850 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7852 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7856 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7857 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7858 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7859 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7860 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7861 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7862 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7863 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7864 digest_buf
[8] = 0; // needed for base64_encode ()
7866 char tmp_buf
[64] = { 0 };
7868 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7872 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7874 else if (hash_mode
== 10100)
7876 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7881 byte_swap_32 (salt
.salt_buf
[0]),
7882 byte_swap_32 (salt
.salt_buf
[1]),
7883 byte_swap_32 (salt
.salt_buf
[2]),
7884 byte_swap_32 (salt
.salt_buf
[3]));
7886 else if (hash_mode
== 10200)
7888 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7890 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7894 char challenge
[100] = { 0 };
7896 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7900 char tmp_buf
[100] = { 0 };
7902 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7903 (char *) cram_md5
->user
,
7909 char response
[100] = { 0 };
7911 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7913 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7915 else if (hash_mode
== 10300)
7917 char tmp_buf
[100] = { 0 };
7919 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7920 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7922 uint tmp_len
= 20 + salt
.salt_len
;
7926 char base64_encoded
[100] = { 0 };
7928 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7930 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7932 else if (hash_mode
== 10400)
7934 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7936 pdf_t
*pdf
= &pdfs
[salt_pos
];
7938 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",
7946 byte_swap_32 (pdf
->id_buf
[0]),
7947 byte_swap_32 (pdf
->id_buf
[1]),
7948 byte_swap_32 (pdf
->id_buf
[2]),
7949 byte_swap_32 (pdf
->id_buf
[3]),
7951 byte_swap_32 (pdf
->u_buf
[0]),
7952 byte_swap_32 (pdf
->u_buf
[1]),
7953 byte_swap_32 (pdf
->u_buf
[2]),
7954 byte_swap_32 (pdf
->u_buf
[3]),
7955 byte_swap_32 (pdf
->u_buf
[4]),
7956 byte_swap_32 (pdf
->u_buf
[5]),
7957 byte_swap_32 (pdf
->u_buf
[6]),
7958 byte_swap_32 (pdf
->u_buf
[7]),
7960 byte_swap_32 (pdf
->o_buf
[0]),
7961 byte_swap_32 (pdf
->o_buf
[1]),
7962 byte_swap_32 (pdf
->o_buf
[2]),
7963 byte_swap_32 (pdf
->o_buf
[3]),
7964 byte_swap_32 (pdf
->o_buf
[4]),
7965 byte_swap_32 (pdf
->o_buf
[5]),
7966 byte_swap_32 (pdf
->o_buf
[6]),
7967 byte_swap_32 (pdf
->o_buf
[7])
7970 else if (hash_mode
== 10410)
7972 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7974 pdf_t
*pdf
= &pdfs
[salt_pos
];
7976 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",
7984 byte_swap_32 (pdf
->id_buf
[0]),
7985 byte_swap_32 (pdf
->id_buf
[1]),
7986 byte_swap_32 (pdf
->id_buf
[2]),
7987 byte_swap_32 (pdf
->id_buf
[3]),
7989 byte_swap_32 (pdf
->u_buf
[0]),
7990 byte_swap_32 (pdf
->u_buf
[1]),
7991 byte_swap_32 (pdf
->u_buf
[2]),
7992 byte_swap_32 (pdf
->u_buf
[3]),
7993 byte_swap_32 (pdf
->u_buf
[4]),
7994 byte_swap_32 (pdf
->u_buf
[5]),
7995 byte_swap_32 (pdf
->u_buf
[6]),
7996 byte_swap_32 (pdf
->u_buf
[7]),
7998 byte_swap_32 (pdf
->o_buf
[0]),
7999 byte_swap_32 (pdf
->o_buf
[1]),
8000 byte_swap_32 (pdf
->o_buf
[2]),
8001 byte_swap_32 (pdf
->o_buf
[3]),
8002 byte_swap_32 (pdf
->o_buf
[4]),
8003 byte_swap_32 (pdf
->o_buf
[5]),
8004 byte_swap_32 (pdf
->o_buf
[6]),
8005 byte_swap_32 (pdf
->o_buf
[7])
8008 else if (hash_mode
== 10420)
8010 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8012 pdf_t
*pdf
= &pdfs
[salt_pos
];
8014 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8016 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",
8024 byte_swap_32 (pdf
->id_buf
[0]),
8025 byte_swap_32 (pdf
->id_buf
[1]),
8026 byte_swap_32 (pdf
->id_buf
[2]),
8027 byte_swap_32 (pdf
->id_buf
[3]),
8029 byte_swap_32 (pdf
->u_buf
[0]),
8030 byte_swap_32 (pdf
->u_buf
[1]),
8031 byte_swap_32 (pdf
->u_buf
[2]),
8032 byte_swap_32 (pdf
->u_buf
[3]),
8033 byte_swap_32 (pdf
->u_buf
[4]),
8034 byte_swap_32 (pdf
->u_buf
[5]),
8035 byte_swap_32 (pdf
->u_buf
[6]),
8036 byte_swap_32 (pdf
->u_buf
[7]),
8038 byte_swap_32 (pdf
->o_buf
[0]),
8039 byte_swap_32 (pdf
->o_buf
[1]),
8040 byte_swap_32 (pdf
->o_buf
[2]),
8041 byte_swap_32 (pdf
->o_buf
[3]),
8042 byte_swap_32 (pdf
->o_buf
[4]),
8043 byte_swap_32 (pdf
->o_buf
[5]),
8044 byte_swap_32 (pdf
->o_buf
[6]),
8045 byte_swap_32 (pdf
->o_buf
[7]),
8053 else if (hash_mode
== 10500)
8055 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8057 pdf_t
*pdf
= &pdfs
[salt_pos
];
8059 if (pdf
->id_len
== 32)
8061 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",
8069 byte_swap_32 (pdf
->id_buf
[0]),
8070 byte_swap_32 (pdf
->id_buf
[1]),
8071 byte_swap_32 (pdf
->id_buf
[2]),
8072 byte_swap_32 (pdf
->id_buf
[3]),
8073 byte_swap_32 (pdf
->id_buf
[4]),
8074 byte_swap_32 (pdf
->id_buf
[5]),
8075 byte_swap_32 (pdf
->id_buf
[6]),
8076 byte_swap_32 (pdf
->id_buf
[7]),
8078 byte_swap_32 (pdf
->u_buf
[0]),
8079 byte_swap_32 (pdf
->u_buf
[1]),
8080 byte_swap_32 (pdf
->u_buf
[2]),
8081 byte_swap_32 (pdf
->u_buf
[3]),
8082 byte_swap_32 (pdf
->u_buf
[4]),
8083 byte_swap_32 (pdf
->u_buf
[5]),
8084 byte_swap_32 (pdf
->u_buf
[6]),
8085 byte_swap_32 (pdf
->u_buf
[7]),
8087 byte_swap_32 (pdf
->o_buf
[0]),
8088 byte_swap_32 (pdf
->o_buf
[1]),
8089 byte_swap_32 (pdf
->o_buf
[2]),
8090 byte_swap_32 (pdf
->o_buf
[3]),
8091 byte_swap_32 (pdf
->o_buf
[4]),
8092 byte_swap_32 (pdf
->o_buf
[5]),
8093 byte_swap_32 (pdf
->o_buf
[6]),
8094 byte_swap_32 (pdf
->o_buf
[7])
8099 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",
8107 byte_swap_32 (pdf
->id_buf
[0]),
8108 byte_swap_32 (pdf
->id_buf
[1]),
8109 byte_swap_32 (pdf
->id_buf
[2]),
8110 byte_swap_32 (pdf
->id_buf
[3]),
8112 byte_swap_32 (pdf
->u_buf
[0]),
8113 byte_swap_32 (pdf
->u_buf
[1]),
8114 byte_swap_32 (pdf
->u_buf
[2]),
8115 byte_swap_32 (pdf
->u_buf
[3]),
8116 byte_swap_32 (pdf
->u_buf
[4]),
8117 byte_swap_32 (pdf
->u_buf
[5]),
8118 byte_swap_32 (pdf
->u_buf
[6]),
8119 byte_swap_32 (pdf
->u_buf
[7]),
8121 byte_swap_32 (pdf
->o_buf
[0]),
8122 byte_swap_32 (pdf
->o_buf
[1]),
8123 byte_swap_32 (pdf
->o_buf
[2]),
8124 byte_swap_32 (pdf
->o_buf
[3]),
8125 byte_swap_32 (pdf
->o_buf
[4]),
8126 byte_swap_32 (pdf
->o_buf
[5]),
8127 byte_swap_32 (pdf
->o_buf
[6]),
8128 byte_swap_32 (pdf
->o_buf
[7])
8132 else if (hash_mode
== 10600)
8134 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8136 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8137 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8139 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8141 else if (hash_mode
== 10700)
8143 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8145 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8146 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8148 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8150 else if (hash_mode
== 10900)
8152 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8154 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8155 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8157 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8159 else if (hash_mode
== 11100)
8161 u32 salt_challenge
= salt
.salt_buf
[0];
8163 salt_challenge
= byte_swap_32 (salt_challenge
);
8165 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8167 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8168 SIGNATURE_POSTGRESQL_AUTH
,
8176 else if (hash_mode
== 11200)
8178 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8179 SIGNATURE_MYSQL_AUTH
,
8180 (unsigned char *) salt
.salt_buf
,
8187 else if (hash_mode
== 11300)
8189 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8191 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8193 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8194 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8195 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8197 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8198 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8199 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8201 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8203 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8205 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8208 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8210 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8212 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8215 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8217 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8219 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8222 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8223 SIGNATURE_BITCOIN_WALLET
,
8227 (unsigned char *) salt
.salt_buf
,
8235 free (cry_master_buf
);
8237 free (public_key_buf
);
8239 else if (hash_mode
== 11400)
8241 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8243 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8244 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8246 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8248 else if (hash_mode
== 11600)
8250 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8252 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8254 const uint data_len
= seven_zip
->data_len
;
8256 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8258 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8260 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8262 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8265 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8266 SIGNATURE_SEVEN_ZIP
,
8270 (char *) seven_zip
->salt_buf
,
8272 seven_zip
->iv_buf
[0],
8273 seven_zip
->iv_buf
[1],
8274 seven_zip
->iv_buf
[2],
8275 seven_zip
->iv_buf
[3],
8277 seven_zip
->data_len
,
8278 seven_zip
->unpack_size
,
8283 else if (hash_mode
== 11700)
8285 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8295 else if (hash_mode
== 11800)
8297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8315 else if (hash_mode
== 11900)
8317 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8319 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8320 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8322 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8324 else if (hash_mode
== 12000)
8326 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8328 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8329 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8331 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8333 else if (hash_mode
== 12100)
8335 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8337 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8338 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8340 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8342 else if (hash_mode
== 12200)
8344 uint
*ptr_digest
= digest_buf
;
8345 uint
*ptr_salt
= salt
.salt_buf
;
8347 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8354 else if (hash_mode
== 12300)
8356 uint
*ptr_digest
= digest_buf
;
8357 uint
*ptr_salt
= salt
.salt_buf
;
8359 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",
8360 ptr_digest
[ 0], ptr_digest
[ 1],
8361 ptr_digest
[ 2], ptr_digest
[ 3],
8362 ptr_digest
[ 4], ptr_digest
[ 5],
8363 ptr_digest
[ 6], ptr_digest
[ 7],
8364 ptr_digest
[ 8], ptr_digest
[ 9],
8365 ptr_digest
[10], ptr_digest
[11],
8366 ptr_digest
[12], ptr_digest
[13],
8367 ptr_digest
[14], ptr_digest
[15],
8373 else if (hash_mode
== 12400)
8375 // encode iteration count
8377 char salt_iter
[5] = { 0 };
8379 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8380 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8381 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8382 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8387 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8388 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8389 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8390 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8395 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8397 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8398 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8400 memcpy (tmp_buf
, digest_buf
, 8);
8402 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8406 // fill the resulting buffer
8408 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8410 else if (hash_mode
== 12500)
8412 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8414 byte_swap_32 (salt
.salt_buf
[0]),
8415 byte_swap_32 (salt
.salt_buf
[1]),
8421 else if (hash_mode
== 12600)
8423 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8424 digest_buf
[0] + salt
.salt_buf_pc
[0],
8425 digest_buf
[1] + salt
.salt_buf_pc
[1],
8426 digest_buf
[2] + salt
.salt_buf_pc
[2],
8427 digest_buf
[3] + salt
.salt_buf_pc
[3],
8428 digest_buf
[4] + salt
.salt_buf_pc
[4],
8429 digest_buf
[5] + salt
.salt_buf_pc
[5],
8430 digest_buf
[6] + salt
.salt_buf_pc
[6],
8431 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8433 else if (hash_mode
== 12700)
8435 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8437 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8438 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8440 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8442 else if (hash_mode
== 12800)
8444 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8446 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",
8459 byte_swap_32 (digest_buf
[0]),
8460 byte_swap_32 (digest_buf
[1]),
8461 byte_swap_32 (digest_buf
[2]),
8462 byte_swap_32 (digest_buf
[3]),
8463 byte_swap_32 (digest_buf
[4]),
8464 byte_swap_32 (digest_buf
[5]),
8465 byte_swap_32 (digest_buf
[6]),
8466 byte_swap_32 (digest_buf
[7])
8469 else if (hash_mode
== 12900)
8471 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",
8480 byte_swap_32 (digest_buf
[0]),
8481 byte_swap_32 (digest_buf
[1]),
8482 byte_swap_32 (digest_buf
[2]),
8483 byte_swap_32 (digest_buf
[3]),
8484 byte_swap_32 (digest_buf
[4]),
8485 byte_swap_32 (digest_buf
[5]),
8486 byte_swap_32 (digest_buf
[6]),
8487 byte_swap_32 (digest_buf
[7]),
8494 else if (hash_mode
== 13000)
8496 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8498 rar5_t
*rar5
= &rar5s
[salt_pos
];
8500 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8510 byte_swap_32 (digest_buf
[0]),
8511 byte_swap_32 (digest_buf
[1])
8514 else if (hash_mode
== 13100)
8516 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8518 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8520 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8521 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8523 char data
[2560 * 4 * 2] = { 0 };
8525 char *ptr_data
= data
;
8527 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8528 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8533 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8534 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8536 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8538 (char *) krb5tgs
->account_info
,
8542 else if (hash_mode
== 13200)
8544 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8558 else if (hash_mode
== 13300)
8560 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8561 SIGNATURE_AXCRYPT_SHA1
,
8567 else if (hash_mode
== 13400)
8569 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8571 keepass_t
*keepass
= &keepasss
[salt_pos
];
8573 u32 version
= (u32
) keepass
->version
;
8574 u32 rounds
= salt
.salt_iter
;
8575 u32 algorithm
= (u32
) keepass
->algorithm
;
8576 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8578 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8579 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8580 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8581 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8582 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8584 /* specific to version 1 */
8588 /* specific to version 2 */
8589 u32 expected_bytes_len
;
8590 u32
*ptr_expected_bytes
;
8592 u32 final_random_seed_len
;
8593 u32 transf_random_seed_len
;
8595 u32 contents_hash_len
;
8597 transf_random_seed_len
= 8;
8599 contents_hash_len
= 8;
8600 final_random_seed_len
= 8;
8603 final_random_seed_len
= 4;
8605 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8611 char *ptr_data
= out_buf
;
8613 ptr_data
+= strlen(out_buf
);
8618 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8619 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8624 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8625 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8630 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8631 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8638 contents_len
= (u32
) keepass
->contents_len
;
8639 ptr_contents
= (u32
*) keepass
->contents
;
8641 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8642 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8654 char ptr_contents_len
[10] = { 0 };
8656 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8658 sprintf (ptr_data
, "%d", contents_len
);
8660 ptr_data
+= strlen(ptr_contents_len
);
8665 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8666 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8668 else if (version
== 2)
8670 expected_bytes_len
= 8;
8671 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8673 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8674 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8679 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8680 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8694 sprintf (ptr_data
, "%d", keyfile_len
);
8701 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8702 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8705 else if (hash_mode
== 13500)
8707 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8709 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8711 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8713 char pstoken_tmp
[1024 + 1] = { 0 };
8715 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8717 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8719 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8722 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8730 else if (hash_mode
== 13600)
8732 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8734 zip2_t
*zip2
= &zip2s
[salt_pos
];
8736 const u32 salt_len
= zip2
->salt_len
;
8738 char salt_tmp
[32 + 1] = { 0 };
8740 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8742 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8744 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8747 const u32 data_len
= zip2
->data_len
;
8749 char data_tmp
[8192 + 1] = { 0 };
8751 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8753 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8755 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8758 const u32 auth_len
= zip2
->auth_len
;
8760 char auth_tmp
[20 + 1] = { 0 };
8762 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8764 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8766 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8769 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8770 SIGNATURE_ZIP2_START
,
8776 zip2
->compress_length
,
8779 SIGNATURE_ZIP2_STOP
);
8781 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8783 snprintf (out_buf
, len
-1, "%s", hashfile
);
8785 else if (hash_mode
== 13800)
8787 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8789 win8phone_t
*esalt
= &esalts
[salt_pos
];
8791 char buf
[256 + 1] = { 0 };
8793 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8795 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8798 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8811 if (hash_type
== HASH_TYPE_MD4
)
8813 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8819 else if (hash_type
== HASH_TYPE_MD5
)
8821 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8827 else if (hash_type
== HASH_TYPE_SHA1
)
8829 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8836 else if (hash_type
== HASH_TYPE_SHA256
)
8838 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8848 else if (hash_type
== HASH_TYPE_SHA384
)
8850 uint
*ptr
= digest_buf
;
8852 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8860 else if (hash_type
== HASH_TYPE_SHA512
)
8862 uint
*ptr
= digest_buf
;
8864 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8874 else if (hash_type
== HASH_TYPE_LM
)
8876 snprintf (out_buf
, len
-1, "%08x%08x",
8880 else if (hash_type
== HASH_TYPE_ORACLEH
)
8882 snprintf (out_buf
, len
-1, "%08X%08X",
8886 else if (hash_type
== HASH_TYPE_BCRYPT
)
8888 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8889 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8891 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8893 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8895 else if (hash_type
== HASH_TYPE_KECCAK
)
8897 uint
*ptr
= digest_buf
;
8899 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",
8927 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8929 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8931 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8938 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8940 digest_buf
[ 0] = digest_buf
[ 0];
8941 digest_buf
[ 1] = digest_buf
[ 1];
8942 digest_buf
[ 2] = digest_buf
[ 2];
8943 digest_buf
[ 3] = digest_buf
[ 3];
8944 digest_buf
[ 4] = digest_buf
[ 4];
8945 digest_buf
[ 5] = digest_buf
[ 5];
8946 digest_buf
[ 6] = digest_buf
[ 6];
8947 digest_buf
[ 7] = digest_buf
[ 7];
8948 digest_buf
[ 8] = digest_buf
[ 8];
8949 digest_buf
[ 9] = digest_buf
[ 9];
8950 digest_buf
[10] = digest_buf
[10];
8951 digest_buf
[11] = digest_buf
[11];
8952 digest_buf
[12] = digest_buf
[12];
8953 digest_buf
[13] = digest_buf
[13];
8954 digest_buf
[14] = digest_buf
[14];
8955 digest_buf
[15] = digest_buf
[15];
8957 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8975 else if (hash_type
== HASH_TYPE_GOST
)
8977 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8987 else if (hash_type
== HASH_TYPE_MYSQL
)
8989 snprintf (out_buf
, len
-1, "%08x%08x",
8993 else if (hash_type
== HASH_TYPE_LOTUS5
)
8995 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9001 else if (hash_type
== HASH_TYPE_LOTUS6
)
9003 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9004 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9005 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9006 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9008 char buf
[16] = { 0 };
9010 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9011 memcpy (buf
+ 5, digest_buf
, 9);
9015 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9017 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9020 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9022 else if (hash_type
== HASH_TYPE_LOTUS8
)
9024 char buf
[52] = { 0 };
9028 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9034 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9038 buf
[26] = salt
.salt_buf_pc
[0];
9039 buf
[27] = salt
.salt_buf_pc
[1];
9043 memcpy (buf
+ 28, digest_buf
, 8);
9045 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9049 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9051 else if (hash_type
== HASH_TYPE_CRC32
)
9053 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9057 if (salt_type
== SALT_TYPE_INTERN
)
9059 size_t pos
= strlen (out_buf
);
9061 out_buf
[pos
] = data
.separator
;
9063 char *ptr
= (char *) salt
.salt_buf
;
9065 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9067 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9071 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9073 memset (hccap
, 0, sizeof (hccap_t
));
9075 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9077 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9079 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9080 wpa_t
*wpa
= &wpas
[salt_pos
];
9082 hccap
->keyver
= wpa
->keyver
;
9084 hccap
->eapol_size
= wpa
->eapol_size
;
9086 if (wpa
->keyver
!= 1)
9088 uint eapol_tmp
[64] = { 0 };
9090 for (uint i
= 0; i
< 64; i
++)
9092 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9095 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9099 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9102 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9103 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9104 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9105 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9107 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9109 uint dgst_size
= data
.dgst_size
;
9111 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9113 if (wpa
->keyver
!= 1)
9115 uint digest_tmp
[4] = { 0 };
9117 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9118 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9119 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9120 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9122 memcpy (hccap
->keymic
, digest_tmp
, 16);
9126 memcpy (hccap
->keymic
, digest_ptr
, 16);
9130 void SuspendThreads ()
9132 if (data
.devices_status
== STATUS_RUNNING
)
9134 hc_timer_set (&data
.timer_paused
);
9136 data
.devices_status
= STATUS_PAUSED
;
9138 log_info ("Paused");
9142 void ResumeThreads ()
9144 if (data
.devices_status
== STATUS_PAUSED
)
9148 hc_timer_get (data
.timer_paused
, ms_paused
);
9150 data
.ms_paused
+= ms_paused
;
9152 data
.devices_status
= STATUS_RUNNING
;
9154 log_info ("Resumed");
9160 if (data
.devices_status
!= STATUS_RUNNING
) return;
9162 data
.devices_status
= STATUS_BYPASS
;
9164 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9167 void stop_at_checkpoint ()
9169 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9171 if (data
.devices_status
!= STATUS_RUNNING
) return;
9174 // this feature only makes sense if --restore-disable was not specified
9176 if (data
.restore_disable
== 1)
9178 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9183 // check if monitoring of Restore Point updates should be enabled or disabled
9185 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9187 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9189 // save the current restore point value
9191 data
.checkpoint_cur_words
= get_lowest_words_done ();
9193 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9197 data
.devices_status
= STATUS_RUNNING
;
9199 // reset the global value for checkpoint checks
9201 data
.checkpoint_cur_words
= 0;
9203 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9209 //if (data.devices_status == STATUS_INIT) return;
9210 //if (data.devices_status == STATUS_STARTING) return;
9212 data
.devices_status
= STATUS_ABORTED
;
9217 //if (data.devices_status == STATUS_INIT) return;
9218 //if (data.devices_status == STATUS_STARTING) return;
9220 data
.devices_status
= STATUS_QUIT
;
9223 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9225 const size_t len
= strlen (s
);
9227 for (size_t in
= 0; in
< len
; in
++)
9233 s
[in
] = replace_char
;
9238 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9240 char s_escaped
[1024] = { 0 };
9242 size_t s_escaped_max
= sizeof (s_escaped
);
9244 const size_t len
= strlen (s
);
9246 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9252 s_escaped
[out
] = escape_char
;
9257 if (out
== s_escaped_max
- 2) break;
9262 strncpy (s
, s_escaped
, s_max
- 1);
9265 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9267 FILE *fp
= fopen (kernel_file
, "rb");
9273 memset (&st
, 0, sizeof (st
));
9275 stat (kernel_file
, &st
);
9277 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9279 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9281 if (num_read
!= (size_t) st
.st_size
)
9283 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9290 buf
[st
.st_size
] = 0;
9292 for (int i
= 0; i
< num_devices
; i
++)
9294 kernel_lengths
[i
] = (size_t) st
.st_size
;
9296 kernel_sources
[i
] = buf
;
9301 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9309 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9311 if (binary_size
> 0)
9313 FILE *fp
= fopen (dst
, "wb");
9316 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9327 restore_data_t
*init_restore (int argc
, char **argv
)
9329 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9331 if (data
.restore_disable
== 0)
9333 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9337 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9341 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9350 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9352 int pidbin_len
= -1;
9355 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9357 FILE *fd
= fopen (pidbin
, "rb");
9361 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9363 pidbin
[pidbin_len
] = 0;
9367 char *argv0_r
= strrchr (argv
[0], '/');
9369 char *pidbin_r
= strrchr (pidbin
, '/');
9371 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9373 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9375 if (strcmp (argv0_r
, pidbin_r
) == 0)
9377 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9384 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9386 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9388 int pidbin2_len
= -1;
9390 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9391 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9393 pidbin
[pidbin_len
] = 0;
9394 pidbin2
[pidbin2_len
] = 0;
9398 if (strcmp (pidbin
, pidbin2
) == 0)
9400 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9413 if (rd
->version_bin
< RESTORE_MIN
)
9415 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9422 memset (rd
, 0, sizeof (restore_data_t
));
9424 rd
->version_bin
= VERSION_BIN
;
9427 rd
->pid
= getpid ();
9429 rd
->pid
= GetCurrentProcessId ();
9432 if (getcwd (rd
->cwd
, 255) == NULL
)
9445 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9447 FILE *fp
= fopen (eff_restore_file
, "rb");
9451 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9456 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9458 log_error ("ERROR: Can't read %s", eff_restore_file
);
9463 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9465 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9467 for (uint i
= 0; i
< rd
->argc
; i
++)
9469 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9471 log_error ("ERROR: Can't read %s", eff_restore_file
);
9476 size_t len
= strlen (buf
);
9478 if (len
) buf
[len
- 1] = 0;
9480 rd
->argv
[i
] = mystrdup (buf
);
9487 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9489 if (chdir (rd
->cwd
))
9491 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9492 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9493 " https://github.com/philsmd/analyze_hc_restore\n"
9494 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9500 u64
get_lowest_words_done ()
9504 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9506 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9508 if (device_param
->skipped
) continue;
9510 const u64 words_done
= device_param
->words_done
;
9512 if (words_done
< words_cur
) words_cur
= words_done
;
9515 // It's possible that a device's workload isn't finished right after a restore-case.
9516 // In that case, this function would return 0 and overwrite the real restore point
9517 // There's also data.words_cur which is set to rd->words_cur but it changes while
9518 // the attack is running therefore we should stick to rd->words_cur.
9519 // Note that -s influences rd->words_cur we should keep a close look on that.
9521 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9526 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9528 u64 words_cur
= get_lowest_words_done ();
9530 rd
->words_cur
= words_cur
;
9532 FILE *fp
= fopen (new_restore_file
, "wb");
9536 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9541 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9543 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9548 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9550 for (uint i
= 0; i
< rd
->argc
; i
++)
9552 fprintf (fp
, "%s", rd
->argv
[i
]);
9558 fsync (fileno (fp
));
9563 void cycle_restore ()
9565 const char *eff_restore_file
= data
.eff_restore_file
;
9566 const char *new_restore_file
= data
.new_restore_file
;
9568 restore_data_t
*rd
= data
.rd
;
9570 write_restore (new_restore_file
, rd
);
9574 memset (&st
, 0, sizeof(st
));
9576 if (stat (eff_restore_file
, &st
) == 0)
9578 if (unlink (eff_restore_file
))
9580 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9584 if (rename (new_restore_file
, eff_restore_file
))
9586 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9590 void check_checkpoint ()
9592 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9594 u64 words_cur
= get_lowest_words_done ();
9596 if (words_cur
!= data
.checkpoint_cur_words
)
9606 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9610 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9612 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9614 myfree (alias
->device_name
);
9615 myfree (alias
->alias_name
);
9618 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9620 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9622 myfree (entry
->device_name
);
9625 myfree (tuning_db
->alias_buf
);
9626 myfree (tuning_db
->entry_buf
);
9631 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9633 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9635 int num_lines
= count_lines (fp
);
9637 // a bit over-allocated
9639 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9640 tuning_db
->alias_cnt
= 0;
9642 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9643 tuning_db
->entry_cnt
= 0;
9648 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9650 FILE *fp
= fopen (tuning_db_file
, "rb");
9654 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9659 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9665 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9669 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9671 if (line_buf
== NULL
) break;
9675 const int line_len
= in_superchop (line_buf
);
9677 if (line_len
== 0) continue;
9679 if (line_buf
[0] == '#') continue;
9683 char *token_ptr
[7] = { NULL
};
9687 char *next
= strtok (line_buf
, "\t ");
9689 token_ptr
[token_cnt
] = next
;
9693 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9695 token_ptr
[token_cnt
] = next
;
9702 char *device_name
= token_ptr
[0];
9703 char *alias_name
= token_ptr
[1];
9705 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9707 alias
->device_name
= mystrdup (device_name
);
9708 alias
->alias_name
= mystrdup (alias_name
);
9710 tuning_db
->alias_cnt
++;
9712 else if (token_cnt
== 6)
9714 if ((token_ptr
[1][0] != '0') &&
9715 (token_ptr
[1][0] != '1') &&
9716 (token_ptr
[1][0] != '3') &&
9717 (token_ptr
[1][0] != '*'))
9719 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9724 if ((token_ptr
[3][0] != '1') &&
9725 (token_ptr
[3][0] != '2') &&
9726 (token_ptr
[3][0] != '4') &&
9727 (token_ptr
[3][0] != '8') &&
9728 (token_ptr
[3][0] != 'N'))
9730 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9735 char *device_name
= token_ptr
[0];
9737 int attack_mode
= -1;
9739 int vector_width
= -1;
9740 int kernel_accel
= -1;
9741 int kernel_loops
= -1;
9743 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9744 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9745 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9747 if (token_ptr
[4][0] != 'A')
9749 kernel_accel
= atoi (token_ptr
[4]);
9751 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9753 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9763 if (token_ptr
[5][0] != 'A')
9765 kernel_loops
= atoi (token_ptr
[5]);
9767 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9769 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9779 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9781 entry
->device_name
= mystrdup (device_name
);
9782 entry
->attack_mode
= attack_mode
;
9783 entry
->hash_type
= hash_type
;
9784 entry
->vector_width
= vector_width
;
9785 entry
->kernel_accel
= kernel_accel
;
9786 entry
->kernel_loops
= kernel_loops
;
9788 tuning_db
->entry_cnt
++;
9792 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9802 // todo: print loaded 'cnt' message
9804 // sort the database
9806 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9807 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9812 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9814 static tuning_db_entry_t s
;
9816 // first we need to convert all spaces in the device_name to underscore
9818 char *device_name_nospace
= strdup (device_param
->device_name
);
9820 int device_name_length
= strlen (device_name_nospace
);
9824 for (i
= 0; i
< device_name_length
; i
++)
9826 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9829 // find out if there's an alias configured
9831 tuning_db_alias_t a
;
9833 a
.device_name
= device_name_nospace
;
9835 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
);
9837 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9839 // attack-mode 6 and 7 are attack-mode 1 basically
9841 if (attack_mode
== 6) attack_mode
= 1;
9842 if (attack_mode
== 7) attack_mode
= 1;
9844 // bsearch is not ideal but fast enough
9846 s
.device_name
= device_name_nospace
;
9847 s
.attack_mode
= attack_mode
;
9848 s
.hash_type
= hash_type
;
9850 tuning_db_entry_t
*entry
= NULL
;
9852 // this will produce all 2^3 combinations required
9854 for (i
= 0; i
< 8; i
++)
9856 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9857 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9858 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9860 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9862 if (entry
!= NULL
) break;
9864 // in non-wildcard mode do some additional checks:
9868 // in case we have an alias-name
9870 if (alias_name
!= NULL
)
9872 s
.device_name
= alias_name
;
9874 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9876 if (entry
!= NULL
) break;
9879 // or by device type
9881 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9883 s
.device_name
= "DEVICE_TYPE_CPU";
9885 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9887 s
.device_name
= "DEVICE_TYPE_GPU";
9889 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9891 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9894 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9896 if (entry
!= NULL
) break;
9900 // free converted device_name
9902 myfree (device_name_nospace
);
9911 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9913 u8 tmp
[256] = { 0 };
9915 if (salt_len
> sizeof (tmp
))
9920 memcpy (tmp
, in
, salt_len
);
9922 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9924 if ((salt_len
% 2) == 0)
9926 u32 new_salt_len
= salt_len
/ 2;
9928 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9933 tmp
[i
] = hex_convert (p1
) << 0;
9934 tmp
[i
] |= hex_convert (p0
) << 4;
9937 salt_len
= new_salt_len
;
9944 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9946 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9949 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9951 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9955 u32
*tmp_uint
= (u32
*) tmp
;
9957 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9958 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9959 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9960 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9961 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9962 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9963 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9964 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9965 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9966 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9968 salt_len
= salt_len
* 2;
9976 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9978 lowercase (tmp
, salt_len
);
9981 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9983 uppercase (tmp
, salt_len
);
9988 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9993 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9998 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10000 u32
*tmp_uint
= (uint
*) tmp
;
10004 if (len
% 4) max
++;
10006 for (u32 i
= 0; i
< max
; i
++)
10008 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10011 // Important: we may need to increase the length of memcpy since
10012 // we don't want to "loose" some swapped bytes (could happen if
10013 // they do not perfectly fit in the 4-byte blocks)
10014 // Memcpy does always copy the bytes in the BE order, but since
10015 // we swapped them, some important bytes could be in positions
10016 // we normally skip with the original len
10018 if (len
% 4) len
+= 4 - (len
% 4);
10021 memcpy (out
, tmp
, len
);
10026 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10028 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10030 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10032 u32
*digest
= (u32
*) hash_buf
->digest
;
10034 salt_t
*salt
= hash_buf
->salt
;
10036 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10038 char *iter_pos
= input_buf
+ 4;
10040 salt
->salt_iter
= 1 << atoi (iter_pos
);
10042 char *salt_pos
= strchr (iter_pos
, '$');
10044 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10048 uint salt_len
= 16;
10050 salt
->salt_len
= salt_len
;
10052 u8 tmp_buf
[100] = { 0 };
10054 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10058 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10060 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10061 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10062 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10063 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10065 char *hash_pos
= salt_pos
+ 22;
10067 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10069 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10071 memcpy (digest
, tmp_buf
, 24);
10073 digest
[0] = byte_swap_32 (digest
[0]);
10074 digest
[1] = byte_swap_32 (digest
[1]);
10075 digest
[2] = byte_swap_32 (digest
[2]);
10076 digest
[3] = byte_swap_32 (digest
[3]);
10077 digest
[4] = byte_swap_32 (digest
[4]);
10078 digest
[5] = byte_swap_32 (digest
[5]);
10080 digest
[5] &= ~0xff; // its just 23 not 24 !
10082 return (PARSER_OK
);
10085 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10087 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10089 u32
*digest
= (u32
*) hash_buf
->digest
;
10091 u8 tmp_buf
[100] = { 0 };
10093 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10095 memcpy (digest
, tmp_buf
, 32);
10097 digest
[0] = byte_swap_32 (digest
[0]);
10098 digest
[1] = byte_swap_32 (digest
[1]);
10099 digest
[2] = byte_swap_32 (digest
[2]);
10100 digest
[3] = byte_swap_32 (digest
[3]);
10101 digest
[4] = byte_swap_32 (digest
[4]);
10102 digest
[5] = byte_swap_32 (digest
[5]);
10103 digest
[6] = byte_swap_32 (digest
[6]);
10104 digest
[7] = byte_swap_32 (digest
[7]);
10106 digest
[0] -= SHA256M_A
;
10107 digest
[1] -= SHA256M_B
;
10108 digest
[2] -= SHA256M_C
;
10109 digest
[3] -= SHA256M_D
;
10110 digest
[4] -= SHA256M_E
;
10111 digest
[5] -= SHA256M_F
;
10112 digest
[6] -= SHA256M_G
;
10113 digest
[7] -= SHA256M_H
;
10115 return (PARSER_OK
);
10118 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10120 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10122 u32
*digest
= (u32
*) hash_buf
->digest
;
10124 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10125 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10127 digest
[0] = byte_swap_32 (digest
[0]);
10128 digest
[1] = byte_swap_32 (digest
[1]);
10132 IP (digest
[0], digest
[1], tt
);
10134 digest
[0] = digest
[0];
10135 digest
[1] = digest
[1];
10139 return (PARSER_OK
);
10142 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10144 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10146 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10148 u32
*digest
= (u32
*) hash_buf
->digest
;
10150 salt_t
*salt
= hash_buf
->salt
;
10152 char *hash_pos
= input_buf
+ 10;
10154 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10155 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10156 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10157 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10158 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10160 digest
[0] -= SHA1M_A
;
10161 digest
[1] -= SHA1M_B
;
10162 digest
[2] -= SHA1M_C
;
10163 digest
[3] -= SHA1M_D
;
10164 digest
[4] -= SHA1M_E
;
10166 uint salt_len
= 10;
10168 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10170 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10172 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10174 salt
->salt_len
= salt_len
;
10176 return (PARSER_OK
);
10179 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10181 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10183 u32
*digest
= (u32
*) hash_buf
->digest
;
10185 salt_t
*salt
= hash_buf
->salt
;
10187 char *hash_pos
= input_buf
+ 8;
10189 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10190 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10191 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10192 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10193 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10195 digest
[0] -= SHA1M_A
;
10196 digest
[1] -= SHA1M_B
;
10197 digest
[2] -= SHA1M_C
;
10198 digest
[3] -= SHA1M_D
;
10199 digest
[4] -= SHA1M_E
;
10203 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10205 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10207 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10209 salt
->salt_len
= salt_len
;
10211 return (PARSER_OK
);
10214 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10216 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10218 u64
*digest
= (u64
*) hash_buf
->digest
;
10220 salt_t
*salt
= hash_buf
->salt
;
10222 char *hash_pos
= input_buf
+ 8;
10224 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10225 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10226 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10227 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10228 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10229 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10230 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10231 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10233 digest
[0] -= SHA512M_A
;
10234 digest
[1] -= SHA512M_B
;
10235 digest
[2] -= SHA512M_C
;
10236 digest
[3] -= SHA512M_D
;
10237 digest
[4] -= SHA512M_E
;
10238 digest
[5] -= SHA512M_F
;
10239 digest
[6] -= SHA512M_G
;
10240 digest
[7] -= SHA512M_H
;
10244 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10246 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10248 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10250 salt
->salt_len
= salt_len
;
10252 return (PARSER_OK
);
10255 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10257 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10259 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10263 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10266 u32
*digest
= (u32
*) hash_buf
->digest
;
10268 salt_t
*salt
= hash_buf
->salt
;
10270 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10271 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10272 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10273 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10275 digest
[0] = byte_swap_32 (digest
[0]);
10276 digest
[1] = byte_swap_32 (digest
[1]);
10277 digest
[2] = byte_swap_32 (digest
[2]);
10278 digest
[3] = byte_swap_32 (digest
[3]);
10280 digest
[0] -= MD5M_A
;
10281 digest
[1] -= MD5M_B
;
10282 digest
[2] -= MD5M_C
;
10283 digest
[3] -= MD5M_D
;
10285 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10287 uint salt_len
= input_len
- 32 - 1;
10289 char *salt_buf
= input_buf
+ 32 + 1;
10291 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10293 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10295 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10297 salt
->salt_len
= salt_len
;
10299 return (PARSER_OK
);
10302 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10304 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10306 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10310 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10315 char clean_input_buf
[32] = { 0 };
10317 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10318 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10320 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10324 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10330 clean_input_buf
[k
] = input_buf
[i
];
10338 u32
*digest
= (u32
*) hash_buf
->digest
;
10340 salt_t
*salt
= hash_buf
->salt
;
10342 u32 a
, b
, c
, d
, e
, f
;
10344 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10345 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10346 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10347 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10348 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10349 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10351 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10352 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10354 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10355 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10356 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10357 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10358 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10359 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10361 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10362 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10364 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10365 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10366 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10367 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10368 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10369 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10371 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10372 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10374 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10375 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10376 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10377 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10378 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10379 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10381 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10382 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10384 digest
[0] = byte_swap_32 (digest
[0]);
10385 digest
[1] = byte_swap_32 (digest
[1]);
10386 digest
[2] = byte_swap_32 (digest
[2]);
10387 digest
[3] = byte_swap_32 (digest
[3]);
10389 digest
[0] -= MD5M_A
;
10390 digest
[1] -= MD5M_B
;
10391 digest
[2] -= MD5M_C
;
10392 digest
[3] -= MD5M_D
;
10394 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10396 uint salt_len
= input_len
- 30 - 1;
10398 char *salt_buf
= input_buf
+ 30 + 1;
10400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10402 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10404 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10405 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10407 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10409 salt
->salt_len
= salt_len
;
10411 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10413 salt
->salt_len
+= 22;
10415 return (PARSER_OK
);
10418 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10420 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10422 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10426 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10429 u32
*digest
= (u32
*) hash_buf
->digest
;
10431 salt_t
*salt
= hash_buf
->salt
;
10433 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10434 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10435 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10436 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10437 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10439 digest
[0] -= SHA1M_A
;
10440 digest
[1] -= SHA1M_B
;
10441 digest
[2] -= SHA1M_C
;
10442 digest
[3] -= SHA1M_D
;
10443 digest
[4] -= SHA1M_E
;
10445 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10447 uint salt_len
= input_len
- 40 - 1;
10449 char *salt_buf
= input_buf
+ 40 + 1;
10451 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10453 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10455 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10457 salt
->salt_len
= salt_len
;
10459 return (PARSER_OK
);
10462 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10464 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10466 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10470 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10473 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10475 char *iter_pos
= input_buf
+ 6;
10477 salt_t
*salt
= hash_buf
->salt
;
10479 uint iter
= atoi (iter_pos
);
10483 iter
= ROUNDS_DCC2
;
10486 salt
->salt_iter
= iter
- 1;
10488 char *salt_pos
= strchr (iter_pos
, '#');
10490 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10494 char *digest_pos
= strchr (salt_pos
, '#');
10496 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10500 uint salt_len
= digest_pos
- salt_pos
- 1;
10502 u32
*digest
= (u32
*) hash_buf
->digest
;
10504 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10505 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10506 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10507 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10509 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10511 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10513 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10515 salt
->salt_len
= salt_len
;
10517 return (PARSER_OK
);
10520 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10522 u32
*digest
= (u32
*) hash_buf
->digest
;
10524 salt_t
*salt
= hash_buf
->salt
;
10526 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10530 memcpy (&in
, input_buf
, input_len
);
10532 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10534 memcpy (digest
, in
.keymic
, 16);
10537 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10538 The phrase "Pairwise key expansion"
10539 Access Point Address (referred to as Authenticator Address AA)
10540 Supplicant Address (referred to as Supplicant Address SA)
10541 Access Point Nonce (referred to as Authenticator Anonce)
10542 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10545 uint salt_len
= strlen (in
.essid
);
10549 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10551 return (PARSER_SALT_LENGTH
);
10554 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10556 salt
->salt_len
= salt_len
;
10558 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10560 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10562 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10564 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10566 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10567 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10571 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10572 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10575 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10577 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10578 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10582 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10583 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10586 for (int i
= 0; i
< 25; i
++)
10588 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10591 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10592 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10593 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10594 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10596 wpa
->keyver
= in
.keyver
;
10598 if (wpa
->keyver
> 255)
10600 log_info ("ATTENTION!");
10601 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10602 log_info (" This could be due to a recent aircrack-ng bug.");
10603 log_info (" The key version was automatically reset to a reasonable value.");
10606 wpa
->keyver
&= 0xff;
10609 wpa
->eapol_size
= in
.eapol_size
;
10611 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10613 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10615 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10617 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10619 if (wpa
->keyver
== 1)
10625 digest
[0] = byte_swap_32 (digest
[0]);
10626 digest
[1] = byte_swap_32 (digest
[1]);
10627 digest
[2] = byte_swap_32 (digest
[2]);
10628 digest
[3] = byte_swap_32 (digest
[3]);
10630 for (int i
= 0; i
< 64; i
++)
10632 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10636 uint32_t *p0
= (uint32_t *) in
.essid
;
10640 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10641 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10643 salt
->salt_buf
[10] = c0
;
10644 salt
->salt_buf
[11] = c1
;
10646 return (PARSER_OK
);
10649 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10651 u32
*digest
= (u32
*) hash_buf
->digest
;
10653 salt_t
*salt
= hash_buf
->salt
;
10655 if (input_len
== 0)
10657 log_error ("Password Safe v2 container not specified");
10662 FILE *fp
= fopen (input_buf
, "rb");
10666 log_error ("%s: %s", input_buf
, strerror (errno
));
10673 memset (&buf
, 0, sizeof (psafe2_hdr
));
10675 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10679 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10681 salt
->salt_buf
[0] = buf
.random
[0];
10682 salt
->salt_buf
[1] = buf
.random
[1];
10684 salt
->salt_len
= 8;
10685 salt
->salt_iter
= 1000;
10687 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10688 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10689 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10690 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10691 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10693 return (PARSER_OK
);
10696 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10698 u32
*digest
= (u32
*) hash_buf
->digest
;
10700 salt_t
*salt
= hash_buf
->salt
;
10702 if (input_len
== 0)
10704 log_error (".psafe3 not specified");
10709 FILE *fp
= fopen (input_buf
, "rb");
10713 log_error ("%s: %s", input_buf
, strerror (errno
));
10720 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10724 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10726 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10728 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10730 salt
->salt_iter
= in
.iterations
+ 1;
10732 salt
->salt_buf
[0] = in
.salt_buf
[0];
10733 salt
->salt_buf
[1] = in
.salt_buf
[1];
10734 salt
->salt_buf
[2] = in
.salt_buf
[2];
10735 salt
->salt_buf
[3] = in
.salt_buf
[3];
10736 salt
->salt_buf
[4] = in
.salt_buf
[4];
10737 salt
->salt_buf
[5] = in
.salt_buf
[5];
10738 salt
->salt_buf
[6] = in
.salt_buf
[6];
10739 salt
->salt_buf
[7] = in
.salt_buf
[7];
10741 salt
->salt_len
= 32;
10743 digest
[0] = in
.hash_buf
[0];
10744 digest
[1] = in
.hash_buf
[1];
10745 digest
[2] = in
.hash_buf
[2];
10746 digest
[3] = in
.hash_buf
[3];
10747 digest
[4] = in
.hash_buf
[4];
10748 digest
[5] = in
.hash_buf
[5];
10749 digest
[6] = in
.hash_buf
[6];
10750 digest
[7] = in
.hash_buf
[7];
10752 digest
[0] = byte_swap_32 (digest
[0]);
10753 digest
[1] = byte_swap_32 (digest
[1]);
10754 digest
[2] = byte_swap_32 (digest
[2]);
10755 digest
[3] = byte_swap_32 (digest
[3]);
10756 digest
[4] = byte_swap_32 (digest
[4]);
10757 digest
[5] = byte_swap_32 (digest
[5]);
10758 digest
[6] = byte_swap_32 (digest
[6]);
10759 digest
[7] = byte_swap_32 (digest
[7]);
10761 return (PARSER_OK
);
10764 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10766 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10768 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10770 u32
*digest
= (u32
*) hash_buf
->digest
;
10772 salt_t
*salt
= hash_buf
->salt
;
10774 char *iter_pos
= input_buf
+ 3;
10776 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10778 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10780 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10782 salt
->salt_iter
= salt_iter
;
10784 char *salt_pos
= iter_pos
+ 1;
10788 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10790 salt
->salt_len
= salt_len
;
10792 char *hash_pos
= salt_pos
+ salt_len
;
10794 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10796 return (PARSER_OK
);
10799 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10801 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10803 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10805 u32
*digest
= (u32
*) hash_buf
->digest
;
10807 salt_t
*salt
= hash_buf
->salt
;
10809 char *salt_pos
= input_buf
+ 3;
10811 uint iterations_len
= 0;
10813 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10817 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10819 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10820 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10824 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10828 iterations_len
+= 8;
10832 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10835 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10837 char *hash_pos
= strchr (salt_pos
, '$');
10839 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10841 uint salt_len
= hash_pos
- salt_pos
;
10843 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10845 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10847 salt
->salt_len
= salt_len
;
10851 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10853 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10855 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10857 return (PARSER_OK
);
10860 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10862 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10864 u32
*digest
= (u32
*) hash_buf
->digest
;
10866 salt_t
*salt
= hash_buf
->salt
;
10868 char *salt_pos
= input_buf
+ 6;
10870 uint iterations_len
= 0;
10872 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10876 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10878 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10879 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10883 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10887 iterations_len
+= 8;
10891 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10894 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10896 char *hash_pos
= strchr (salt_pos
, '$');
10898 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10900 uint salt_len
= hash_pos
- salt_pos
;
10902 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10904 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10906 salt
->salt_len
= salt_len
;
10910 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10912 return (PARSER_OK
);
10915 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10917 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10919 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10921 u32
*digest
= (u32
*) hash_buf
->digest
;
10923 salt_t
*salt
= hash_buf
->salt
;
10925 char *salt_pos
= input_buf
+ 14;
10927 char *hash_pos
= strchr (salt_pos
, '*');
10929 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10933 uint salt_len
= hash_pos
- salt_pos
- 1;
10935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10937 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10941 salt
->salt_len
= salt_len
;
10943 u8 tmp_buf
[100] = { 0 };
10945 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10947 memcpy (digest
, tmp_buf
, 20);
10949 digest
[0] = byte_swap_32 (digest
[0]);
10950 digest
[1] = byte_swap_32 (digest
[1]);
10951 digest
[2] = byte_swap_32 (digest
[2]);
10952 digest
[3] = byte_swap_32 (digest
[3]);
10953 digest
[4] = byte_swap_32 (digest
[4]);
10955 digest
[0] -= SHA1M_A
;
10956 digest
[1] -= SHA1M_B
;
10957 digest
[2] -= SHA1M_C
;
10958 digest
[3] -= SHA1M_D
;
10959 digest
[4] -= SHA1M_E
;
10961 return (PARSER_OK
);
10964 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10966 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10968 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10970 if (c12
& 3) return (PARSER_HASH_VALUE
);
10972 u32
*digest
= (u32
*) hash_buf
->digest
;
10974 salt_t
*salt
= hash_buf
->salt
;
10976 // for ascii_digest
10977 salt
->salt_sign
[0] = input_buf
[0];
10978 salt
->salt_sign
[1] = input_buf
[1];
10980 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10981 | itoa64_to_int (input_buf
[1]) << 6;
10983 salt
->salt_len
= 2;
10985 u8 tmp_buf
[100] = { 0 };
10987 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10989 memcpy (digest
, tmp_buf
, 8);
10993 IP (digest
[0], digest
[1], tt
);
10998 return (PARSER_OK
);
11001 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11003 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11005 u32
*digest
= (u32
*) hash_buf
->digest
;
11007 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11008 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11009 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11010 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11012 digest
[0] = byte_swap_32 (digest
[0]);
11013 digest
[1] = byte_swap_32 (digest
[1]);
11014 digest
[2] = byte_swap_32 (digest
[2]);
11015 digest
[3] = byte_swap_32 (digest
[3]);
11017 digest
[0] -= MD4M_A
;
11018 digest
[1] -= MD4M_B
;
11019 digest
[2] -= MD4M_C
;
11020 digest
[3] -= MD4M_D
;
11022 return (PARSER_OK
);
11025 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11027 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11029 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11033 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11036 u32
*digest
= (u32
*) hash_buf
->digest
;
11038 salt_t
*salt
= hash_buf
->salt
;
11040 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11041 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11042 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11043 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11045 digest
[0] = byte_swap_32 (digest
[0]);
11046 digest
[1] = byte_swap_32 (digest
[1]);
11047 digest
[2] = byte_swap_32 (digest
[2]);
11048 digest
[3] = byte_swap_32 (digest
[3]);
11050 digest
[0] -= MD4M_A
;
11051 digest
[1] -= MD4M_B
;
11052 digest
[2] -= MD4M_C
;
11053 digest
[3] -= MD4M_D
;
11055 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11057 uint salt_len
= input_len
- 32 - 1;
11059 char *salt_buf
= input_buf
+ 32 + 1;
11061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11063 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11065 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11067 salt
->salt_len
= salt_len
;
11069 return (PARSER_OK
);
11072 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11074 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11076 u32
*digest
= (u32
*) hash_buf
->digest
;
11078 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11079 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11080 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11081 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11083 digest
[0] = byte_swap_32 (digest
[0]);
11084 digest
[1] = byte_swap_32 (digest
[1]);
11085 digest
[2] = byte_swap_32 (digest
[2]);
11086 digest
[3] = byte_swap_32 (digest
[3]);
11088 digest
[0] -= MD5M_A
;
11089 digest
[1] -= MD5M_B
;
11090 digest
[2] -= MD5M_C
;
11091 digest
[3] -= MD5M_D
;
11093 return (PARSER_OK
);
11096 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11098 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11100 u32
*digest
= (u32
*) hash_buf
->digest
;
11102 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11103 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11107 digest
[0] = byte_swap_32 (digest
[0]);
11108 digest
[1] = byte_swap_32 (digest
[1]);
11110 return (PARSER_OK
);
11113 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11115 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11117 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11121 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11124 u32
*digest
= (u32
*) hash_buf
->digest
;
11126 salt_t
*salt
= hash_buf
->salt
;
11128 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11129 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11130 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11131 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11133 digest
[0] = byte_swap_32 (digest
[0]);
11134 digest
[1] = byte_swap_32 (digest
[1]);
11135 digest
[2] = byte_swap_32 (digest
[2]);
11136 digest
[3] = byte_swap_32 (digest
[3]);
11138 digest
[0] -= MD5M_A
;
11139 digest
[1] -= MD5M_B
;
11140 digest
[2] -= MD5M_C
;
11141 digest
[3] -= MD5M_D
;
11143 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11145 uint salt_len
= input_len
- 32 - 1;
11147 char *salt_buf
= input_buf
+ 32 + 1;
11149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11151 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11155 salt
->salt_len
= salt_len
;
11157 return (PARSER_OK
);
11160 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11162 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11164 u32
*digest
= (u32
*) hash_buf
->digest
;
11166 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11167 | itoa64_to_int (input_buf
[ 1]) << 6
11168 | itoa64_to_int (input_buf
[ 2]) << 12
11169 | itoa64_to_int (input_buf
[ 3]) << 18;
11170 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11171 | itoa64_to_int (input_buf
[ 5]) << 6
11172 | itoa64_to_int (input_buf
[ 6]) << 12
11173 | itoa64_to_int (input_buf
[ 7]) << 18;
11174 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11175 | itoa64_to_int (input_buf
[ 9]) << 6
11176 | itoa64_to_int (input_buf
[10]) << 12
11177 | itoa64_to_int (input_buf
[11]) << 18;
11178 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11179 | itoa64_to_int (input_buf
[13]) << 6
11180 | itoa64_to_int (input_buf
[14]) << 12
11181 | itoa64_to_int (input_buf
[15]) << 18;
11183 digest
[0] -= MD5M_A
;
11184 digest
[1] -= MD5M_B
;
11185 digest
[2] -= MD5M_C
;
11186 digest
[3] -= MD5M_D
;
11188 digest
[0] &= 0x00ffffff;
11189 digest
[1] &= 0x00ffffff;
11190 digest
[2] &= 0x00ffffff;
11191 digest
[3] &= 0x00ffffff;
11193 return (PARSER_OK
);
11196 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11198 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11200 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11204 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11207 u32
*digest
= (u32
*) hash_buf
->digest
;
11209 salt_t
*salt
= hash_buf
->salt
;
11211 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11212 | itoa64_to_int (input_buf
[ 1]) << 6
11213 | itoa64_to_int (input_buf
[ 2]) << 12
11214 | itoa64_to_int (input_buf
[ 3]) << 18;
11215 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11216 | itoa64_to_int (input_buf
[ 5]) << 6
11217 | itoa64_to_int (input_buf
[ 6]) << 12
11218 | itoa64_to_int (input_buf
[ 7]) << 18;
11219 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11220 | itoa64_to_int (input_buf
[ 9]) << 6
11221 | itoa64_to_int (input_buf
[10]) << 12
11222 | itoa64_to_int (input_buf
[11]) << 18;
11223 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11224 | itoa64_to_int (input_buf
[13]) << 6
11225 | itoa64_to_int (input_buf
[14]) << 12
11226 | itoa64_to_int (input_buf
[15]) << 18;
11228 digest
[0] -= MD5M_A
;
11229 digest
[1] -= MD5M_B
;
11230 digest
[2] -= MD5M_C
;
11231 digest
[3] -= MD5M_D
;
11233 digest
[0] &= 0x00ffffff;
11234 digest
[1] &= 0x00ffffff;
11235 digest
[2] &= 0x00ffffff;
11236 digest
[3] &= 0x00ffffff;
11238 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11240 uint salt_len
= input_len
- 16 - 1;
11242 char *salt_buf
= input_buf
+ 16 + 1;
11244 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11246 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11248 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11250 salt
->salt_len
= salt_len
;
11252 return (PARSER_OK
);
11255 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11257 key
[0] = (nthash
[0] >> 0);
11258 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11259 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11260 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11261 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11262 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11263 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11264 key
[7] = (nthash
[6] << 1);
11276 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11278 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11280 u32
*digest
= (u32
*) hash_buf
->digest
;
11282 salt_t
*salt
= hash_buf
->salt
;
11284 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11290 char *user_pos
= input_buf
;
11292 char *unused_pos
= strchr (user_pos
, ':');
11294 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11296 uint user_len
= unused_pos
- user_pos
;
11298 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11302 char *domain_pos
= strchr (unused_pos
, ':');
11304 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11306 uint unused_len
= domain_pos
- unused_pos
;
11308 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11312 char *srvchall_pos
= strchr (domain_pos
, ':');
11314 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11316 uint domain_len
= srvchall_pos
- domain_pos
;
11318 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11322 char *hash_pos
= strchr (srvchall_pos
, ':');
11324 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11326 uint srvchall_len
= hash_pos
- srvchall_pos
;
11328 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11332 char *clichall_pos
= strchr (hash_pos
, ':');
11334 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11336 uint hash_len
= clichall_pos
- hash_pos
;
11338 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11342 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11344 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11347 * store some data for later use
11350 netntlm
->user_len
= user_len
* 2;
11351 netntlm
->domain_len
= domain_len
* 2;
11352 netntlm
->srvchall_len
= srvchall_len
/ 2;
11353 netntlm
->clichall_len
= clichall_len
/ 2;
11355 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11356 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11359 * handle username and domainname
11362 for (uint i
= 0; i
< user_len
; i
++)
11364 *userdomain_ptr
++ = user_pos
[i
];
11365 *userdomain_ptr
++ = 0;
11368 for (uint i
= 0; i
< domain_len
; i
++)
11370 *userdomain_ptr
++ = domain_pos
[i
];
11371 *userdomain_ptr
++ = 0;
11375 * handle server challenge encoding
11378 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11380 const char p0
= srvchall_pos
[i
+ 0];
11381 const char p1
= srvchall_pos
[i
+ 1];
11383 *chall_ptr
++ = hex_convert (p1
) << 0
11384 | hex_convert (p0
) << 4;
11388 * handle client challenge encoding
11391 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11393 const char p0
= clichall_pos
[i
+ 0];
11394 const char p1
= clichall_pos
[i
+ 1];
11396 *chall_ptr
++ = hex_convert (p1
) << 0
11397 | hex_convert (p0
) << 4;
11404 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11406 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11408 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11410 salt
->salt_len
= salt_len
;
11412 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11413 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11414 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11415 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11417 digest
[0] = byte_swap_32 (digest
[0]);
11418 digest
[1] = byte_swap_32 (digest
[1]);
11419 digest
[2] = byte_swap_32 (digest
[2]);
11420 digest
[3] = byte_swap_32 (digest
[3]);
11422 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11424 uint digest_tmp
[2] = { 0 };
11426 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11427 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11429 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11430 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11432 /* special case 2: ESS */
11434 if (srvchall_len
== 48)
11436 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11438 uint w
[16] = { 0 };
11440 w
[ 0] = netntlm
->chall_buf
[6];
11441 w
[ 1] = netntlm
->chall_buf
[7];
11442 w
[ 2] = netntlm
->chall_buf
[0];
11443 w
[ 3] = netntlm
->chall_buf
[1];
11447 uint dgst
[4] = { 0 };
11456 salt
->salt_buf
[0] = dgst
[0];
11457 salt
->salt_buf
[1] = dgst
[1];
11461 /* precompute netntlmv1 exploit start */
11463 for (uint i
= 0; i
< 0x10000; i
++)
11465 uint key_md4
[2] = { i
, 0 };
11466 uint key_des
[2] = { 0, 0 };
11468 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11470 uint Kc
[16] = { 0 };
11471 uint Kd
[16] = { 0 };
11473 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11475 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11477 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11479 if (data3
[0] != digest_tmp
[0]) continue;
11480 if (data3
[1] != digest_tmp
[1]) continue;
11482 salt
->salt_buf
[2] = i
;
11484 salt
->salt_len
= 24;
11489 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11490 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11492 /* precompute netntlmv1 exploit stop */
11496 IP (digest
[0], digest
[1], tt
);
11497 IP (digest
[2], digest
[3], tt
);
11499 digest
[0] = rotr32 (digest
[0], 29);
11500 digest
[1] = rotr32 (digest
[1], 29);
11501 digest
[2] = rotr32 (digest
[2], 29);
11502 digest
[3] = rotr32 (digest
[3], 29);
11504 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11506 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11507 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11509 return (PARSER_OK
);
11512 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11514 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11516 u32
*digest
= (u32
*) hash_buf
->digest
;
11518 salt_t
*salt
= hash_buf
->salt
;
11520 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11526 char *user_pos
= input_buf
;
11528 char *unused_pos
= strchr (user_pos
, ':');
11530 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11532 uint user_len
= unused_pos
- user_pos
;
11534 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11538 char *domain_pos
= strchr (unused_pos
, ':');
11540 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11542 uint unused_len
= domain_pos
- unused_pos
;
11544 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11548 char *srvchall_pos
= strchr (domain_pos
, ':');
11550 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11552 uint domain_len
= srvchall_pos
- domain_pos
;
11554 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11558 char *hash_pos
= strchr (srvchall_pos
, ':');
11560 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11562 uint srvchall_len
= hash_pos
- srvchall_pos
;
11564 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11568 char *clichall_pos
= strchr (hash_pos
, ':');
11570 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11572 uint hash_len
= clichall_pos
- hash_pos
;
11574 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11578 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11580 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11582 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11585 * store some data for later use
11588 netntlm
->user_len
= user_len
* 2;
11589 netntlm
->domain_len
= domain_len
* 2;
11590 netntlm
->srvchall_len
= srvchall_len
/ 2;
11591 netntlm
->clichall_len
= clichall_len
/ 2;
11593 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11594 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11597 * handle username and domainname
11600 for (uint i
= 0; i
< user_len
; i
++)
11602 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11603 *userdomain_ptr
++ = 0;
11606 for (uint i
= 0; i
< domain_len
; i
++)
11608 *userdomain_ptr
++ = domain_pos
[i
];
11609 *userdomain_ptr
++ = 0;
11612 *userdomain_ptr
++ = 0x80;
11615 * handle server challenge encoding
11618 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11620 const char p0
= srvchall_pos
[i
+ 0];
11621 const char p1
= srvchall_pos
[i
+ 1];
11623 *chall_ptr
++ = hex_convert (p1
) << 0
11624 | hex_convert (p0
) << 4;
11628 * handle client challenge encoding
11631 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11633 const char p0
= clichall_pos
[i
+ 0];
11634 const char p1
= clichall_pos
[i
+ 1];
11636 *chall_ptr
++ = hex_convert (p1
) << 0
11637 | hex_convert (p0
) << 4;
11640 *chall_ptr
++ = 0x80;
11643 * handle hash itself
11646 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11647 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11648 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11649 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11651 digest
[0] = byte_swap_32 (digest
[0]);
11652 digest
[1] = byte_swap_32 (digest
[1]);
11653 digest
[2] = byte_swap_32 (digest
[2]);
11654 digest
[3] = byte_swap_32 (digest
[3]);
11657 * reuse challange data as salt_buf, its the buffer that is most likely unique
11660 salt
->salt_buf
[0] = 0;
11661 salt
->salt_buf
[1] = 0;
11662 salt
->salt_buf
[2] = 0;
11663 salt
->salt_buf
[3] = 0;
11664 salt
->salt_buf
[4] = 0;
11665 salt
->salt_buf
[5] = 0;
11666 salt
->salt_buf
[6] = 0;
11667 salt
->salt_buf
[7] = 0;
11671 uptr
= (uint
*) netntlm
->userdomain_buf
;
11673 for (uint i
= 0; i
< 16; i
+= 16)
11675 md5_64 (uptr
, salt
->salt_buf
);
11678 uptr
= (uint
*) netntlm
->chall_buf
;
11680 for (uint i
= 0; i
< 256; i
+= 16)
11682 md5_64 (uptr
, salt
->salt_buf
);
11685 salt
->salt_len
= 16;
11687 return (PARSER_OK
);
11690 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11692 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11694 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11698 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11701 u32
*digest
= (u32
*) hash_buf
->digest
;
11703 salt_t
*salt
= hash_buf
->salt
;
11705 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11706 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11707 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11708 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11710 digest
[0] = byte_swap_32 (digest
[0]);
11711 digest
[1] = byte_swap_32 (digest
[1]);
11712 digest
[2] = byte_swap_32 (digest
[2]);
11713 digest
[3] = byte_swap_32 (digest
[3]);
11715 digest
[0] -= MD5M_A
;
11716 digest
[1] -= MD5M_B
;
11717 digest
[2] -= MD5M_C
;
11718 digest
[3] -= MD5M_D
;
11720 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11722 uint salt_len
= input_len
- 32 - 1;
11724 char *salt_buf
= input_buf
+ 32 + 1;
11726 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11728 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11730 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11732 salt
->salt_len
= salt_len
;
11734 return (PARSER_OK
);
11737 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11739 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11741 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11745 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11748 u32
*digest
= (u32
*) hash_buf
->digest
;
11750 salt_t
*salt
= hash_buf
->salt
;
11752 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11753 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11754 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11755 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11757 digest
[0] = byte_swap_32 (digest
[0]);
11758 digest
[1] = byte_swap_32 (digest
[1]);
11759 digest
[2] = byte_swap_32 (digest
[2]);
11760 digest
[3] = byte_swap_32 (digest
[3]);
11762 digest
[0] -= MD5M_A
;
11763 digest
[1] -= MD5M_B
;
11764 digest
[2] -= MD5M_C
;
11765 digest
[3] -= MD5M_D
;
11767 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11769 uint salt_len
= input_len
- 32 - 1;
11771 char *salt_buf
= input_buf
+ 32 + 1;
11773 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11775 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11777 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11779 salt
->salt_len
= salt_len
;
11781 return (PARSER_OK
);
11784 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11786 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11788 u32
*digest
= (u32
*) hash_buf
->digest
;
11790 salt_t
*salt
= hash_buf
->salt
;
11792 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11793 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11794 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11795 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11797 digest
[0] = byte_swap_32 (digest
[0]);
11798 digest
[1] = byte_swap_32 (digest
[1]);
11799 digest
[2] = byte_swap_32 (digest
[2]);
11800 digest
[3] = byte_swap_32 (digest
[3]);
11802 digest
[0] -= MD5M_A
;
11803 digest
[1] -= MD5M_B
;
11804 digest
[2] -= MD5M_C
;
11805 digest
[3] -= MD5M_D
;
11808 * This is a virtual salt. While the algorithm is basically not salted
11809 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11810 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11813 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11815 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11817 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11819 salt
->salt_len
= salt_len
;
11821 return (PARSER_OK
);
11824 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11826 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11828 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11832 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11835 u32
*digest
= (u32
*) hash_buf
->digest
;
11837 salt_t
*salt
= hash_buf
->salt
;
11839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11841 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11842 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11844 digest
[0] = byte_swap_32 (digest
[0]);
11845 digest
[1] = byte_swap_32 (digest
[1]);
11846 digest
[2] = byte_swap_32 (digest
[2]);
11847 digest
[3] = byte_swap_32 (digest
[3]);
11849 digest
[0] -= MD5M_A
;
11850 digest
[1] -= MD5M_B
;
11851 digest
[2] -= MD5M_C
;
11852 digest
[3] -= MD5M_D
;
11854 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11856 uint salt_len
= input_len
- 32 - 1;
11858 char *salt_buf
= input_buf
+ 32 + 1;
11860 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11862 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11864 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11866 salt
->salt_len
= salt_len
;
11868 return (PARSER_OK
);
11871 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11873 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11875 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11879 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11882 u32
*digest
= (u32
*) hash_buf
->digest
;
11884 salt_t
*salt
= hash_buf
->salt
;
11886 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11887 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11888 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11889 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11891 digest
[0] = byte_swap_32 (digest
[0]);
11892 digest
[1] = byte_swap_32 (digest
[1]);
11893 digest
[2] = byte_swap_32 (digest
[2]);
11894 digest
[3] = byte_swap_32 (digest
[3]);
11896 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11898 uint salt_len
= input_len
- 32 - 1;
11900 char *salt_buf
= input_buf
+ 32 + 1;
11902 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11904 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11906 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11908 salt
->salt_len
= salt_len
;
11910 return (PARSER_OK
);
11913 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11915 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11917 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11921 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11924 u32
*digest
= (u32
*) hash_buf
->digest
;
11926 salt_t
*salt
= hash_buf
->salt
;
11928 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11929 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11930 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11931 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11933 digest
[0] = byte_swap_32 (digest
[0]);
11934 digest
[1] = byte_swap_32 (digest
[1]);
11935 digest
[2] = byte_swap_32 (digest
[2]);
11936 digest
[3] = byte_swap_32 (digest
[3]);
11938 digest
[0] -= MD4M_A
;
11939 digest
[1] -= MD4M_B
;
11940 digest
[2] -= MD4M_C
;
11941 digest
[3] -= MD4M_D
;
11943 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11945 uint salt_len
= input_len
- 32 - 1;
11947 char *salt_buf
= input_buf
+ 32 + 1;
11949 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11951 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11953 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11955 salt
->salt_len
= salt_len
;
11957 return (PARSER_OK
);
11960 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11962 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11964 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11968 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11971 u32
*digest
= (u32
*) hash_buf
->digest
;
11973 salt_t
*salt
= hash_buf
->salt
;
11975 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11976 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11977 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11978 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11980 digest
[0] = byte_swap_32 (digest
[0]);
11981 digest
[1] = byte_swap_32 (digest
[1]);
11982 digest
[2] = byte_swap_32 (digest
[2]);
11983 digest
[3] = byte_swap_32 (digest
[3]);
11985 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11987 uint salt_len
= input_len
- 32 - 1;
11989 char *salt_buf
= input_buf
+ 32 + 1;
11991 uint salt_pc_block
[16] = { 0 };
11993 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11995 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11997 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11999 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12001 salt_pc_block
[14] = salt_len
* 8;
12003 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12005 md5_64 (salt_pc_block
, salt_pc_digest
);
12007 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12008 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12009 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12010 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12012 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12014 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12016 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12018 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12019 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12020 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12021 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12023 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12025 return (PARSER_OK
);
12028 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12030 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12032 u32
*digest
= (u32
*) hash_buf
->digest
;
12034 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12035 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12036 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12037 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12038 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12040 digest
[0] -= SHA1M_A
;
12041 digest
[1] -= SHA1M_B
;
12042 digest
[2] -= SHA1M_C
;
12043 digest
[3] -= SHA1M_D
;
12044 digest
[4] -= SHA1M_E
;
12046 return (PARSER_OK
);
12049 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12051 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12053 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12055 u32
*digest
= (u32
*) hash_buf
->digest
;
12059 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12060 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12061 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12062 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12065 return (PARSER_OK
);
12068 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12070 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12072 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12076 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12079 u32
*digest
= (u32
*) hash_buf
->digest
;
12081 salt_t
*salt
= hash_buf
->salt
;
12083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12087 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12089 digest
[0] -= SHA1M_A
;
12090 digest
[1] -= SHA1M_B
;
12091 digest
[2] -= SHA1M_C
;
12092 digest
[3] -= SHA1M_D
;
12093 digest
[4] -= SHA1M_E
;
12095 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12097 uint salt_len
= input_len
- 40 - 1;
12099 char *salt_buf
= input_buf
+ 40 + 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 pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12114 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12116 u32
*digest
= (u32
*) hash_buf
->digest
;
12118 salt_t
*salt
= hash_buf
->salt
;
12120 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12122 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12123 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12124 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12125 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12126 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12128 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12130 uint salt_len
= input_len
- 40 - 1;
12132 char *salt_buf
= input_buf
+ 40 + 1;
12134 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12136 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12138 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12140 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12143 pstoken
->salt_len
= salt_len
/ 2;
12145 /* some fake salt for the sorting mechanisms */
12147 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12148 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12149 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12150 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12151 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12152 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12153 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12154 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12156 salt
->salt_len
= 32;
12158 /* we need to check if we can precompute some of the data --
12159 this is possible since the scheme is badly designed */
12161 pstoken
->pc_digest
[0] = SHA1M_A
;
12162 pstoken
->pc_digest
[1] = SHA1M_B
;
12163 pstoken
->pc_digest
[2] = SHA1M_C
;
12164 pstoken
->pc_digest
[3] = SHA1M_D
;
12165 pstoken
->pc_digest
[4] = SHA1M_E
;
12167 pstoken
->pc_offset
= 0;
12169 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12173 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12174 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12175 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12176 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12177 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12178 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12179 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12180 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12181 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12182 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12183 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12184 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12185 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12186 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12187 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12188 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12190 sha1_64 (w
, pstoken
->pc_digest
);
12192 pstoken
->pc_offset
+= 16;
12195 return (PARSER_OK
);
12198 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12200 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12202 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12204 u32
*digest
= (u32
*) hash_buf
->digest
;
12206 u8 tmp_buf
[100] = { 0 };
12208 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12210 memcpy (digest
, tmp_buf
, 20);
12212 digest
[0] = byte_swap_32 (digest
[0]);
12213 digest
[1] = byte_swap_32 (digest
[1]);
12214 digest
[2] = byte_swap_32 (digest
[2]);
12215 digest
[3] = byte_swap_32 (digest
[3]);
12216 digest
[4] = byte_swap_32 (digest
[4]);
12218 digest
[0] -= SHA1M_A
;
12219 digest
[1] -= SHA1M_B
;
12220 digest
[2] -= SHA1M_C
;
12221 digest
[3] -= SHA1M_D
;
12222 digest
[4] -= SHA1M_E
;
12224 return (PARSER_OK
);
12227 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12229 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12231 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12233 u32
*digest
= (u32
*) hash_buf
->digest
;
12235 salt_t
*salt
= hash_buf
->salt
;
12237 u8 tmp_buf
[100] = { 0 };
12239 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12241 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12243 memcpy (digest
, tmp_buf
, 20);
12245 int salt_len
= tmp_len
- 20;
12247 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12249 salt
->salt_len
= salt_len
;
12251 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12253 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12255 char *ptr
= (char *) salt
->salt_buf
;
12257 ptr
[salt
->salt_len
] = 0x80;
12260 digest
[0] = byte_swap_32 (digest
[0]);
12261 digest
[1] = byte_swap_32 (digest
[1]);
12262 digest
[2] = byte_swap_32 (digest
[2]);
12263 digest
[3] = byte_swap_32 (digest
[3]);
12264 digest
[4] = byte_swap_32 (digest
[4]);
12266 digest
[0] -= SHA1M_A
;
12267 digest
[1] -= SHA1M_B
;
12268 digest
[2] -= SHA1M_C
;
12269 digest
[3] -= SHA1M_D
;
12270 digest
[4] -= SHA1M_E
;
12272 return (PARSER_OK
);
12275 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12277 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12279 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12281 u32
*digest
= (u32
*) hash_buf
->digest
;
12283 salt_t
*salt
= hash_buf
->salt
;
12285 char *salt_buf
= input_buf
+ 6;
12289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12293 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12295 salt
->salt_len
= salt_len
;
12297 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12299 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12300 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12301 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12302 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12303 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12305 digest
[0] -= SHA1M_A
;
12306 digest
[1] -= SHA1M_B
;
12307 digest
[2] -= SHA1M_C
;
12308 digest
[3] -= SHA1M_D
;
12309 digest
[4] -= SHA1M_E
;
12311 return (PARSER_OK
);
12314 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12316 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12318 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12320 u32
*digest
= (u32
*) hash_buf
->digest
;
12322 salt_t
*salt
= hash_buf
->salt
;
12324 char *salt_buf
= input_buf
+ 6;
12328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12330 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12332 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12334 salt
->salt_len
= salt_len
;
12336 char *hash_pos
= input_buf
+ 6 + 8;
12338 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12339 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12340 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12341 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12342 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12344 digest
[0] -= SHA1M_A
;
12345 digest
[1] -= SHA1M_B
;
12346 digest
[2] -= SHA1M_C
;
12347 digest
[3] -= SHA1M_D
;
12348 digest
[4] -= SHA1M_E
;
12350 return (PARSER_OK
);
12353 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12355 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12357 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12359 u64
*digest
= (u64
*) hash_buf
->digest
;
12361 salt_t
*salt
= hash_buf
->salt
;
12363 char *salt_buf
= input_buf
+ 6;
12367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12373 salt
->salt_len
= salt_len
;
12375 char *hash_pos
= input_buf
+ 6 + 8;
12377 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12378 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12379 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12380 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12381 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12382 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12383 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12384 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12386 digest
[0] -= SHA512M_A
;
12387 digest
[1] -= SHA512M_B
;
12388 digest
[2] -= SHA512M_C
;
12389 digest
[3] -= SHA512M_D
;
12390 digest
[4] -= SHA512M_E
;
12391 digest
[5] -= SHA512M_F
;
12392 digest
[6] -= SHA512M_G
;
12393 digest
[7] -= SHA512M_H
;
12395 return (PARSER_OK
);
12398 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12400 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12402 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12406 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12409 u32
*digest
= (u32
*) hash_buf
->digest
;
12411 salt_t
*salt
= hash_buf
->salt
;
12413 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12414 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12418 digest
[0] = byte_swap_32 (digest
[0]);
12419 digest
[1] = byte_swap_32 (digest
[1]);
12421 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12423 uint salt_len
= input_len
- 16 - 1;
12425 char *salt_buf
= input_buf
+ 16 + 1;
12427 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12429 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12431 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12433 salt
->salt_len
= salt_len
;
12435 return (PARSER_OK
);
12438 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12440 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12442 u32
*digest
= (u32
*) hash_buf
->digest
;
12444 salt_t
*salt
= hash_buf
->salt
;
12446 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12447 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12448 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12449 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12450 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12452 digest
[0] -= SHA1M_A
;
12453 digest
[1] -= SHA1M_B
;
12454 digest
[2] -= SHA1M_C
;
12455 digest
[3] -= SHA1M_D
;
12456 digest
[4] -= SHA1M_E
;
12458 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12460 uint salt_len
= input_len
- 40 - 1;
12462 char *salt_buf
= input_buf
+ 40 + 1;
12464 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12466 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12468 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12470 salt
->salt_len
= salt_len
;
12472 return (PARSER_OK
);
12475 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12477 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12479 u32
*digest
= (u32
*) hash_buf
->digest
;
12481 salt_t
*salt
= hash_buf
->salt
;
12483 char *hash_pos
= input_buf
;
12485 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12486 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12487 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12488 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12489 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12490 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12491 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12492 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12493 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12494 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12495 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12496 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12497 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12498 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12499 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12500 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12502 char *salt_pos
= input_buf
+ 128;
12504 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12505 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12506 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12507 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12509 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12510 salt
->salt_len
= 16;
12512 return (PARSER_OK
);
12515 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12517 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12519 u32
*digest
= (u32
*) hash_buf
->digest
;
12521 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12522 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12523 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12524 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12525 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12526 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12527 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12528 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12530 digest
[0] -= SHA256M_A
;
12531 digest
[1] -= SHA256M_B
;
12532 digest
[2] -= SHA256M_C
;
12533 digest
[3] -= SHA256M_D
;
12534 digest
[4] -= SHA256M_E
;
12535 digest
[5] -= SHA256M_F
;
12536 digest
[6] -= SHA256M_G
;
12537 digest
[7] -= SHA256M_H
;
12539 return (PARSER_OK
);
12542 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12544 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12546 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12550 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12553 u32
*digest
= (u32
*) hash_buf
->digest
;
12555 salt_t
*salt
= hash_buf
->salt
;
12557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12559 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12560 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12561 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12562 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12563 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12564 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12566 digest
[0] -= SHA256M_A
;
12567 digest
[1] -= SHA256M_B
;
12568 digest
[2] -= SHA256M_C
;
12569 digest
[3] -= SHA256M_D
;
12570 digest
[4] -= SHA256M_E
;
12571 digest
[5] -= SHA256M_F
;
12572 digest
[6] -= SHA256M_G
;
12573 digest
[7] -= SHA256M_H
;
12575 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12577 uint salt_len
= input_len
- 64 - 1;
12579 char *salt_buf
= input_buf
+ 64 + 1;
12581 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12583 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12585 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12587 salt
->salt_len
= salt_len
;
12589 return (PARSER_OK
);
12592 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12594 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12596 u64
*digest
= (u64
*) hash_buf
->digest
;
12598 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12599 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12600 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12601 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12602 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12603 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12607 digest
[0] -= SHA384M_A
;
12608 digest
[1] -= SHA384M_B
;
12609 digest
[2] -= SHA384M_C
;
12610 digest
[3] -= SHA384M_D
;
12611 digest
[4] -= SHA384M_E
;
12612 digest
[5] -= SHA384M_F
;
12616 return (PARSER_OK
);
12619 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12621 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12623 u64
*digest
= (u64
*) hash_buf
->digest
;
12625 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12626 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12627 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12628 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12629 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12630 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12631 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12632 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12634 digest
[0] -= SHA512M_A
;
12635 digest
[1] -= SHA512M_B
;
12636 digest
[2] -= SHA512M_C
;
12637 digest
[3] -= SHA512M_D
;
12638 digest
[4] -= SHA512M_E
;
12639 digest
[5] -= SHA512M_F
;
12640 digest
[6] -= SHA512M_G
;
12641 digest
[7] -= SHA512M_H
;
12643 return (PARSER_OK
);
12646 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12648 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12650 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12654 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12657 u64
*digest
= (u64
*) hash_buf
->digest
;
12659 salt_t
*salt
= hash_buf
->salt
;
12661 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12662 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12663 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12664 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12665 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12666 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12667 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12668 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12670 digest
[0] -= SHA512M_A
;
12671 digest
[1] -= SHA512M_B
;
12672 digest
[2] -= SHA512M_C
;
12673 digest
[3] -= SHA512M_D
;
12674 digest
[4] -= SHA512M_E
;
12675 digest
[5] -= SHA512M_F
;
12676 digest
[6] -= SHA512M_G
;
12677 digest
[7] -= SHA512M_H
;
12679 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12681 uint salt_len
= input_len
- 128 - 1;
12683 char *salt_buf
= input_buf
+ 128 + 1;
12685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12687 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12691 salt
->salt_len
= salt_len
;
12693 return (PARSER_OK
);
12696 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12698 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12700 u64
*digest
= (u64
*) hash_buf
->digest
;
12702 salt_t
*salt
= hash_buf
->salt
;
12704 char *salt_pos
= input_buf
+ 3;
12706 uint iterations_len
= 0;
12708 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12712 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12714 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12715 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12719 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12723 iterations_len
+= 8;
12727 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12730 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12732 char *hash_pos
= strchr (salt_pos
, '$');
12734 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12736 uint salt_len
= hash_pos
- salt_pos
;
12738 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12740 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12742 salt
->salt_len
= salt_len
;
12746 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12748 return (PARSER_OK
);
12751 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12753 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12755 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12757 u64
*digest
= (u64
*) hash_buf
->digest
;
12759 salt_t
*salt
= hash_buf
->salt
;
12761 uint keccak_mdlen
= input_len
/ 2;
12763 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12765 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12767 digest
[i
] = byte_swap_64 (digest
[i
]);
12770 salt
->keccak_mdlen
= keccak_mdlen
;
12772 return (PARSER_OK
);
12775 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12777 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12779 u32
*digest
= (u32
*) hash_buf
->digest
;
12781 salt_t
*salt
= hash_buf
->salt
;
12783 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12786 * Parse that strange long line
12791 size_t in_len
[9] = { 0 };
12793 in_off
[0] = strtok (input_buf
, ":");
12795 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12797 in_len
[0] = strlen (in_off
[0]);
12801 for (i
= 1; i
< 9; i
++)
12803 in_off
[i
] = strtok (NULL
, ":");
12805 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12807 in_len
[i
] = strlen (in_off
[i
]);
12810 char *ptr
= (char *) ikepsk
->msg_buf
;
12812 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12813 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12814 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12815 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12816 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12817 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12821 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12823 ptr
= (char *) ikepsk
->nr_buf
;
12825 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12826 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12830 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12833 * Store to database
12838 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12839 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12840 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12841 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12843 digest
[0] = byte_swap_32 (digest
[0]);
12844 digest
[1] = byte_swap_32 (digest
[1]);
12845 digest
[2] = byte_swap_32 (digest
[2]);
12846 digest
[3] = byte_swap_32 (digest
[3]);
12848 salt
->salt_len
= 32;
12850 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12851 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12852 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12853 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12854 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12855 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12856 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12857 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12859 return (PARSER_OK
);
12862 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12864 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12866 u32
*digest
= (u32
*) hash_buf
->digest
;
12868 salt_t
*salt
= hash_buf
->salt
;
12870 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12873 * Parse that strange long line
12878 size_t in_len
[9] = { 0 };
12880 in_off
[0] = strtok (input_buf
, ":");
12882 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12884 in_len
[0] = strlen (in_off
[0]);
12888 for (i
= 1; i
< 9; i
++)
12890 in_off
[i
] = strtok (NULL
, ":");
12892 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12894 in_len
[i
] = strlen (in_off
[i
]);
12897 char *ptr
= (char *) ikepsk
->msg_buf
;
12899 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12900 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12901 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12902 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12903 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12904 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12908 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12910 ptr
= (char *) ikepsk
->nr_buf
;
12912 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12913 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12917 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12920 * Store to database
12925 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12926 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12927 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12928 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12929 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12931 salt
->salt_len
= 32;
12933 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12934 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12935 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12936 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12937 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12938 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12939 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12940 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12942 return (PARSER_OK
);
12945 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12947 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12949 u32
*digest
= (u32
*) hash_buf
->digest
;
12951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12953 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12954 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12955 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12957 digest
[0] = byte_swap_32 (digest
[0]);
12958 digest
[1] = byte_swap_32 (digest
[1]);
12959 digest
[2] = byte_swap_32 (digest
[2]);
12960 digest
[3] = byte_swap_32 (digest
[3]);
12961 digest
[4] = byte_swap_32 (digest
[4]);
12963 return (PARSER_OK
);
12966 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12968 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12970 u32
*digest
= (u32
*) hash_buf
->digest
;
12972 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12973 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12974 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12975 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12976 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12977 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12978 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12979 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12980 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12981 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12982 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12983 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12984 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12985 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12986 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12987 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12989 return (PARSER_OK
);
12992 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12994 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12996 u32
*digest
= (u32
*) hash_buf
->digest
;
12998 salt_t
*salt
= hash_buf
->salt
;
13000 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13001 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13002 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13003 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13004 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13006 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13008 uint salt_len
= input_len
- 40 - 1;
13010 char *salt_buf
= input_buf
+ 40 + 1;
13012 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13014 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13016 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13018 salt
->salt_len
= salt_len
;
13020 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13022 return (PARSER_OK
);
13025 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13027 u32
*digest
= (u32
*) hash_buf
->digest
;
13029 salt_t
*salt
= hash_buf
->salt
;
13031 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13033 if (input_len
== 0)
13035 log_error ("TrueCrypt container not specified");
13040 FILE *fp
= fopen (input_buf
, "rb");
13044 log_error ("%s: %s", input_buf
, strerror (errno
));
13049 char buf
[512] = { 0 };
13051 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13055 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13057 memcpy (tc
->salt_buf
, buf
, 64);
13059 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13061 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13063 salt
->salt_len
= 4;
13065 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13067 tc
->signature
= 0x45555254; // "TRUE"
13069 digest
[0] = tc
->data_buf
[0];
13071 return (PARSER_OK
);
13074 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13076 u32
*digest
= (u32
*) hash_buf
->digest
;
13078 salt_t
*salt
= hash_buf
->salt
;
13080 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13082 if (input_len
== 0)
13084 log_error ("TrueCrypt container not specified");
13089 FILE *fp
= fopen (input_buf
, "rb");
13093 log_error ("%s: %s", input_buf
, strerror (errno
));
13098 char buf
[512] = { 0 };
13100 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13104 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13106 memcpy (tc
->salt_buf
, buf
, 64);
13108 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13110 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13112 salt
->salt_len
= 4;
13114 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13116 tc
->signature
= 0x45555254; // "TRUE"
13118 digest
[0] = tc
->data_buf
[0];
13120 return (PARSER_OK
);
13123 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13125 u32
*digest
= (u32
*) hash_buf
->digest
;
13127 salt_t
*salt
= hash_buf
->salt
;
13129 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13131 if (input_len
== 0)
13133 log_error ("VeraCrypt container not specified");
13138 FILE *fp
= fopen (input_buf
, "rb");
13142 log_error ("%s: %s", input_buf
, strerror (errno
));
13147 char buf
[512] = { 0 };
13149 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13153 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13155 memcpy (tc
->salt_buf
, buf
, 64);
13157 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13159 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13161 salt
->salt_len
= 4;
13163 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13165 tc
->signature
= 0x41524556; // "VERA"
13167 digest
[0] = tc
->data_buf
[0];
13169 return (PARSER_OK
);
13172 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13174 u32
*digest
= (u32
*) hash_buf
->digest
;
13176 salt_t
*salt
= hash_buf
->salt
;
13178 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13180 if (input_len
== 0)
13182 log_error ("VeraCrypt container not specified");
13187 FILE *fp
= fopen (input_buf
, "rb");
13191 log_error ("%s: %s", input_buf
, strerror (errno
));
13196 char buf
[512] = { 0 };
13198 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13202 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13204 memcpy (tc
->salt_buf
, buf
, 64);
13206 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13208 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13210 salt
->salt_len
= 4;
13212 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13214 tc
->signature
= 0x41524556; // "VERA"
13216 digest
[0] = tc
->data_buf
[0];
13218 return (PARSER_OK
);
13221 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13223 u32
*digest
= (u32
*) hash_buf
->digest
;
13225 salt_t
*salt
= hash_buf
->salt
;
13227 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13229 if (input_len
== 0)
13231 log_error ("VeraCrypt container not specified");
13236 FILE *fp
= fopen (input_buf
, "rb");
13240 log_error ("%s: %s", input_buf
, strerror (errno
));
13245 char buf
[512] = { 0 };
13247 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13251 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13253 memcpy (tc
->salt_buf
, buf
, 64);
13255 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13257 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13259 salt
->salt_len
= 4;
13261 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13263 tc
->signature
= 0x41524556; // "VERA"
13265 digest
[0] = tc
->data_buf
[0];
13267 return (PARSER_OK
);
13270 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13272 u32
*digest
= (u32
*) hash_buf
->digest
;
13274 salt_t
*salt
= hash_buf
->salt
;
13276 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13278 if (input_len
== 0)
13280 log_error ("VeraCrypt container not specified");
13285 FILE *fp
= fopen (input_buf
, "rb");
13289 log_error ("%s: %s", input_buf
, strerror (errno
));
13294 char buf
[512] = { 0 };
13296 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13300 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13302 memcpy (tc
->salt_buf
, buf
, 64);
13304 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13306 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13308 salt
->salt_len
= 4;
13310 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13312 tc
->signature
= 0x41524556; // "VERA"
13314 digest
[0] = tc
->data_buf
[0];
13316 return (PARSER_OK
);
13319 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13321 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13323 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13325 u32
*digest
= (u32
*) hash_buf
->digest
;
13327 salt_t
*salt
= hash_buf
->salt
;
13329 char *salt_pos
= input_buf
+ 6;
13331 char *hash_pos
= strchr (salt_pos
, '$');
13333 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13335 uint salt_len
= hash_pos
- salt_pos
;
13337 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13339 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13341 salt
->salt_len
= salt_len
;
13343 salt
->salt_iter
= 1000;
13347 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13349 return (PARSER_OK
);
13352 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13354 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13356 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13358 u32
*digest
= (u32
*) hash_buf
->digest
;
13360 salt_t
*salt
= hash_buf
->salt
;
13362 char *iter_pos
= input_buf
+ 7;
13364 char *salt_pos
= strchr (iter_pos
, '$');
13366 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13370 char *hash_pos
= strchr (salt_pos
, '$');
13372 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13374 uint salt_len
= hash_pos
- salt_pos
;
13376 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13378 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13380 salt
->salt_len
= salt_len
;
13382 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13384 salt
->salt_sign
[0] = atoi (salt_iter
);
13386 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13390 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13392 digest
[0] = byte_swap_32 (digest
[0]);
13393 digest
[1] = byte_swap_32 (digest
[1]);
13394 digest
[2] = byte_swap_32 (digest
[2]);
13395 digest
[3] = byte_swap_32 (digest
[3]);
13396 digest
[4] = byte_swap_32 (digest
[4]);
13398 return (PARSER_OK
);
13401 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13403 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13405 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13407 u32
*digest
= (u32
*) hash_buf
->digest
;
13409 salt_t
*salt
= hash_buf
->salt
;
13411 char *iter_pos
= input_buf
+ 9;
13413 char *salt_pos
= strchr (iter_pos
, '$');
13415 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13419 char *hash_pos
= strchr (salt_pos
, '$');
13421 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13423 uint salt_len
= hash_pos
- salt_pos
;
13425 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13427 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13429 salt
->salt_len
= salt_len
;
13431 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13433 salt
->salt_sign
[0] = atoi (salt_iter
);
13435 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13439 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13441 digest
[0] = byte_swap_32 (digest
[0]);
13442 digest
[1] = byte_swap_32 (digest
[1]);
13443 digest
[2] = byte_swap_32 (digest
[2]);
13444 digest
[3] = byte_swap_32 (digest
[3]);
13445 digest
[4] = byte_swap_32 (digest
[4]);
13446 digest
[5] = byte_swap_32 (digest
[5]);
13447 digest
[6] = byte_swap_32 (digest
[6]);
13448 digest
[7] = byte_swap_32 (digest
[7]);
13450 return (PARSER_OK
);
13453 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13455 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13457 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13459 u64
*digest
= (u64
*) hash_buf
->digest
;
13461 salt_t
*salt
= hash_buf
->salt
;
13463 char *iter_pos
= input_buf
+ 9;
13465 char *salt_pos
= strchr (iter_pos
, '$');
13467 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13471 char *hash_pos
= strchr (salt_pos
, '$');
13473 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13475 uint salt_len
= hash_pos
- salt_pos
;
13477 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13479 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13481 salt
->salt_len
= salt_len
;
13483 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13485 salt
->salt_sign
[0] = atoi (salt_iter
);
13487 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13491 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13493 digest
[0] = byte_swap_64 (digest
[0]);
13494 digest
[1] = byte_swap_64 (digest
[1]);
13495 digest
[2] = byte_swap_64 (digest
[2]);
13496 digest
[3] = byte_swap_64 (digest
[3]);
13497 digest
[4] = byte_swap_64 (digest
[4]);
13498 digest
[5] = byte_swap_64 (digest
[5]);
13499 digest
[6] = byte_swap_64 (digest
[6]);
13500 digest
[7] = byte_swap_64 (digest
[7]);
13502 return (PARSER_OK
);
13505 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13507 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13509 u32
*digest
= (u32
*) hash_buf
->digest
;
13511 salt_t
*salt
= hash_buf
->salt
;
13513 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13519 char *iterations_pos
= input_buf
;
13521 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13523 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13525 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13527 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13531 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13533 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13535 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13537 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13539 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13541 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13546 * pbkdf2 iterations
13549 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13552 * handle salt encoding
13555 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13557 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13559 const char p0
= saltbuf_pos
[i
+ 0];
13560 const char p1
= saltbuf_pos
[i
+ 1];
13562 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13563 | hex_convert (p0
) << 4;
13566 salt
->salt_len
= saltbuf_len
/ 2;
13569 * handle cipher encoding
13572 uint
*tmp
= (uint
*) mymalloc (32);
13574 char *cipherbuf_ptr
= (char *) tmp
;
13576 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13578 const char p0
= cipherbuf_pos
[i
+ 0];
13579 const char p1
= cipherbuf_pos
[i
+ 1];
13581 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13582 | hex_convert (p0
) << 4;
13585 // iv is stored at salt_buf 4 (length 16)
13586 // data is stored at salt_buf 8 (length 16)
13588 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13589 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13590 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13591 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13593 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13594 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13595 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13596 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13600 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13602 const char p0
= cipherbuf_pos
[j
+ 0];
13603 const char p1
= cipherbuf_pos
[j
+ 1];
13605 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13606 | hex_convert (p0
) << 4;
13613 digest
[0] = 0x10101010;
13614 digest
[1] = 0x10101010;
13615 digest
[2] = 0x10101010;
13616 digest
[3] = 0x10101010;
13618 return (PARSER_OK
);
13621 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13623 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13625 u32
*digest
= (u32
*) hash_buf
->digest
;
13627 salt_t
*salt
= hash_buf
->salt
;
13629 char *hashbuf_pos
= input_buf
;
13631 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13633 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13635 uint hash_len
= iterations_pos
- hashbuf_pos
;
13637 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13641 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13643 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13645 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13649 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13651 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13653 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13655 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13657 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13659 salt
->salt_len
= salt_len
;
13661 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13663 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13664 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13665 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13666 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13668 return (PARSER_OK
);
13671 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13673 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13675 u32
*digest
= (u32
*) hash_buf
->digest
;
13677 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13678 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13679 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13680 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13681 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13682 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13683 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13684 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13686 digest
[0] = byte_swap_32 (digest
[0]);
13687 digest
[1] = byte_swap_32 (digest
[1]);
13688 digest
[2] = byte_swap_32 (digest
[2]);
13689 digest
[3] = byte_swap_32 (digest
[3]);
13690 digest
[4] = byte_swap_32 (digest
[4]);
13691 digest
[5] = byte_swap_32 (digest
[5]);
13692 digest
[6] = byte_swap_32 (digest
[6]);
13693 digest
[7] = byte_swap_32 (digest
[7]);
13695 return (PARSER_OK
);
13698 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13700 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13702 u32
*digest
= (u32
*) hash_buf
->digest
;
13704 salt_t
*salt
= hash_buf
->salt
;
13706 char *salt_pos
= input_buf
+ 3;
13708 uint iterations_len
= 0;
13710 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13714 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13716 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13717 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13721 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13725 iterations_len
+= 8;
13729 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13732 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13734 char *hash_pos
= strchr (salt_pos
, '$');
13736 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13738 uint salt_len
= hash_pos
- salt_pos
;
13740 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13742 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13744 salt
->salt_len
= salt_len
;
13748 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13750 return (PARSER_OK
);
13753 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13755 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13757 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13759 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13761 u64
*digest
= (u64
*) hash_buf
->digest
;
13763 salt_t
*salt
= hash_buf
->salt
;
13765 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13767 char *iter_pos
= input_buf
+ 4;
13769 char *salt_pos
= strchr (iter_pos
, '$');
13771 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13775 char *hash_pos
= strchr (salt_pos
, '$');
13777 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13779 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13783 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13784 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13785 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13786 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13787 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13788 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13789 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13790 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13792 uint salt_len
= hash_pos
- salt_pos
- 1;
13794 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13796 salt
->salt_len
= salt_len
/ 2;
13798 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13799 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13800 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13801 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13802 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13803 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13804 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13805 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13807 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13808 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13809 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13810 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13811 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13812 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13813 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13814 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13815 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13816 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13818 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13820 salt
->salt_iter
= atoi (iter_pos
) - 1;
13822 return (PARSER_OK
);
13825 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13827 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13829 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13831 u32
*digest
= (u32
*) hash_buf
->digest
;
13833 salt_t
*salt
= hash_buf
->salt
;
13835 char *salt_pos
= input_buf
+ 14;
13837 char *hash_pos
= strchr (salt_pos
, '*');
13839 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13843 uint salt_len
= hash_pos
- salt_pos
- 1;
13845 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13847 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13849 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13851 salt
->salt_len
= salt_len
;
13853 u8 tmp_buf
[100] = { 0 };
13855 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13857 memcpy (digest
, tmp_buf
, 32);
13859 digest
[0] = byte_swap_32 (digest
[0]);
13860 digest
[1] = byte_swap_32 (digest
[1]);
13861 digest
[2] = byte_swap_32 (digest
[2]);
13862 digest
[3] = byte_swap_32 (digest
[3]);
13863 digest
[4] = byte_swap_32 (digest
[4]);
13864 digest
[5] = byte_swap_32 (digest
[5]);
13865 digest
[6] = byte_swap_32 (digest
[6]);
13866 digest
[7] = byte_swap_32 (digest
[7]);
13868 digest
[0] -= SHA256M_A
;
13869 digest
[1] -= SHA256M_B
;
13870 digest
[2] -= SHA256M_C
;
13871 digest
[3] -= SHA256M_D
;
13872 digest
[4] -= SHA256M_E
;
13873 digest
[5] -= SHA256M_F
;
13874 digest
[6] -= SHA256M_G
;
13875 digest
[7] -= SHA256M_H
;
13877 return (PARSER_OK
);
13880 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13882 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13884 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13886 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13888 u64
*digest
= (u64
*) hash_buf
->digest
;
13890 salt_t
*salt
= hash_buf
->salt
;
13892 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13894 char *iter_pos
= input_buf
+ 19;
13896 char *salt_pos
= strchr (iter_pos
, '.');
13898 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13902 char *hash_pos
= strchr (salt_pos
, '.');
13904 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13906 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13910 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13911 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13912 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13913 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13914 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13915 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13916 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13917 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13919 uint salt_len
= hash_pos
- salt_pos
- 1;
13923 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13927 for (i
= 0; i
< salt_len
; i
++)
13929 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13932 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13933 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13935 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13937 salt
->salt_len
= salt_len
;
13939 salt
->salt_iter
= atoi (iter_pos
) - 1;
13941 return (PARSER_OK
);
13944 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13946 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13948 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13950 u64
*digest
= (u64
*) hash_buf
->digest
;
13952 salt_t
*salt
= hash_buf
->salt
;
13954 u8 tmp_buf
[120] = { 0 };
13956 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13958 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13960 memcpy (digest
, tmp_buf
, 64);
13962 digest
[0] = byte_swap_64 (digest
[0]);
13963 digest
[1] = byte_swap_64 (digest
[1]);
13964 digest
[2] = byte_swap_64 (digest
[2]);
13965 digest
[3] = byte_swap_64 (digest
[3]);
13966 digest
[4] = byte_swap_64 (digest
[4]);
13967 digest
[5] = byte_swap_64 (digest
[5]);
13968 digest
[6] = byte_swap_64 (digest
[6]);
13969 digest
[7] = byte_swap_64 (digest
[7]);
13971 digest
[0] -= SHA512M_A
;
13972 digest
[1] -= SHA512M_B
;
13973 digest
[2] -= SHA512M_C
;
13974 digest
[3] -= SHA512M_D
;
13975 digest
[4] -= SHA512M_E
;
13976 digest
[5] -= SHA512M_F
;
13977 digest
[6] -= SHA512M_G
;
13978 digest
[7] -= SHA512M_H
;
13980 int salt_len
= tmp_len
- 64;
13982 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13984 salt
->salt_len
= salt_len
;
13986 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13988 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13990 char *ptr
= (char *) salt
->salt_buf
;
13992 ptr
[salt
->salt_len
] = 0x80;
13995 return (PARSER_OK
);
13998 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14000 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14002 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14006 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14009 u32
*digest
= (u32
*) hash_buf
->digest
;
14011 salt_t
*salt
= hash_buf
->salt
;
14013 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14014 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14015 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14016 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14018 digest
[0] = byte_swap_32 (digest
[0]);
14019 digest
[1] = byte_swap_32 (digest
[1]);
14020 digest
[2] = byte_swap_32 (digest
[2]);
14021 digest
[3] = byte_swap_32 (digest
[3]);
14023 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14025 uint salt_len
= input_len
- 32 - 1;
14027 char *salt_buf
= input_buf
+ 32 + 1;
14029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14031 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14033 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14035 salt
->salt_len
= salt_len
;
14037 return (PARSER_OK
);
14040 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14042 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14044 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14048 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14051 u32
*digest
= (u32
*) hash_buf
->digest
;
14053 salt_t
*salt
= hash_buf
->salt
;
14055 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14056 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14057 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14058 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14059 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14061 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14063 uint salt_len
= input_len
- 40 - 1;
14065 char *salt_buf
= input_buf
+ 40 + 1;
14067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14073 salt
->salt_len
= salt_len
;
14075 return (PARSER_OK
);
14078 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14080 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14082 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14086 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14089 u32
*digest
= (u32
*) hash_buf
->digest
;
14091 salt_t
*salt
= hash_buf
->salt
;
14093 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14094 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14095 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14096 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14097 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14098 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14099 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14100 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14102 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14104 uint salt_len
= input_len
- 64 - 1;
14106 char *salt_buf
= input_buf
+ 64 + 1;
14108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14114 salt
->salt_len
= salt_len
;
14116 return (PARSER_OK
);
14119 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14123 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14127 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14130 u64
*digest
= (u64
*) hash_buf
->digest
;
14132 salt_t
*salt
= hash_buf
->salt
;
14134 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14135 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14136 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14137 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14138 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14139 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14140 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14141 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14143 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14145 uint salt_len
= input_len
- 128 - 1;
14147 char *salt_buf
= input_buf
+ 128 + 1;
14149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14151 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14153 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14155 salt
->salt_len
= salt_len
;
14157 return (PARSER_OK
);
14160 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14162 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14164 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14166 u32
*digest
= (u32
*) hash_buf
->digest
;
14168 salt_t
*salt
= hash_buf
->salt
;
14170 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14176 char *user_pos
= input_buf
+ 10 + 1;
14178 char *realm_pos
= strchr (user_pos
, '$');
14180 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14182 uint user_len
= realm_pos
- user_pos
;
14184 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14188 char *salt_pos
= strchr (realm_pos
, '$');
14190 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14192 uint realm_len
= salt_pos
- realm_pos
;
14194 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14198 char *data_pos
= strchr (salt_pos
, '$');
14200 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14202 uint salt_len
= data_pos
- salt_pos
;
14204 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14208 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14210 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14216 memcpy (krb5pa
->user
, user_pos
, user_len
);
14217 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14218 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14220 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14222 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14224 const char p0
= data_pos
[i
+ 0];
14225 const char p1
= data_pos
[i
+ 1];
14227 *timestamp_ptr
++ = hex_convert (p1
) << 0
14228 | hex_convert (p0
) << 4;
14231 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14233 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14235 const char p0
= data_pos
[i
+ 0];
14236 const char p1
= data_pos
[i
+ 1];
14238 *checksum_ptr
++ = hex_convert (p1
) << 0
14239 | hex_convert (p0
) << 4;
14243 * copy some data to generic buffers to make sorting happy
14246 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14247 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14248 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14249 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14250 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14251 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14252 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14253 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14254 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14256 salt
->salt_len
= 36;
14258 digest
[0] = krb5pa
->checksum
[0];
14259 digest
[1] = krb5pa
->checksum
[1];
14260 digest
[2] = krb5pa
->checksum
[2];
14261 digest
[3] = krb5pa
->checksum
[3];
14263 return (PARSER_OK
);
14266 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14268 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14270 u32
*digest
= (u32
*) hash_buf
->digest
;
14272 salt_t
*salt
= hash_buf
->salt
;
14278 char *salt_pos
= input_buf
;
14280 char *hash_pos
= strchr (salt_pos
, '$');
14282 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14284 uint salt_len
= hash_pos
- salt_pos
;
14286 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14290 uint hash_len
= input_len
- 1 - salt_len
;
14292 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14300 for (uint i
= 0; i
< salt_len
; i
++)
14302 if (salt_pos
[i
] == ' ') continue;
14307 // SAP user names cannot be longer than 12 characters
14308 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14310 // SAP user name cannot start with ! or ?
14311 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14319 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14321 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14323 salt
->salt_len
= salt_len
;
14325 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14326 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14330 digest
[0] = byte_swap_32 (digest
[0]);
14331 digest
[1] = byte_swap_32 (digest
[1]);
14333 return (PARSER_OK
);
14336 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14338 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14340 u32
*digest
= (u32
*) hash_buf
->digest
;
14342 salt_t
*salt
= hash_buf
->salt
;
14348 char *salt_pos
= input_buf
;
14350 char *hash_pos
= strchr (salt_pos
, '$');
14352 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14354 uint salt_len
= hash_pos
- salt_pos
;
14356 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14360 uint hash_len
= input_len
- 1 - salt_len
;
14362 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14370 for (uint i
= 0; i
< salt_len
; i
++)
14372 if (salt_pos
[i
] == ' ') continue;
14377 // SAP user names cannot be longer than 12 characters
14378 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14379 // so far nobody complained so we stay with this because it helps in optimization
14380 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14382 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14384 // SAP user name cannot start with ! or ?
14385 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14393 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14397 salt
->salt_len
= salt_len
;
14399 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14400 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14401 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14402 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14403 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14405 return (PARSER_OK
);
14408 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14410 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14412 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14414 u64
*digest
= (u64
*) hash_buf
->digest
;
14416 salt_t
*salt
= hash_buf
->salt
;
14418 char *iter_pos
= input_buf
+ 3;
14420 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14422 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14424 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14426 salt
->salt_iter
= salt_iter
;
14428 char *salt_pos
= iter_pos
+ 1;
14432 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14434 salt
->salt_len
= salt_len
;
14436 char *hash_pos
= salt_pos
+ salt_len
;
14438 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14442 char *tmp
= (char *) salt
->salt_buf_pc
;
14444 tmp
[0] = hash_pos
[42];
14448 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14449 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14450 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14451 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14457 return (PARSER_OK
);
14460 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14462 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14464 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14466 u32
*digest
= (u32
*) hash_buf
->digest
;
14468 salt_t
*salt
= hash_buf
->salt
;
14470 char *salt_buf
= input_buf
+ 6;
14472 uint salt_len
= 16;
14474 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14476 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14478 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14480 salt
->salt_len
= salt_len
;
14482 char *hash_pos
= input_buf
+ 6 + 16;
14484 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14485 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14486 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14487 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14488 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14489 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14490 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14491 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14493 return (PARSER_OK
);
14496 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14498 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14500 u32
*digest
= (u32
*) hash_buf
->digest
;
14502 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14503 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14507 return (PARSER_OK
);
14510 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14512 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14514 u32
*digest
= (u32
*) hash_buf
->digest
;
14516 salt_t
*salt
= hash_buf
->salt
;
14518 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14520 char *saltbuf_pos
= input_buf
;
14522 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14524 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14526 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14528 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14529 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14531 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14535 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14537 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14539 char *salt_ptr
= (char *) saltbuf_pos
;
14540 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14545 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14547 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14550 rakp_ptr
[j
] = 0x80;
14552 rakp
->salt_len
= j
;
14554 for (i
= 0; i
< 64; i
++)
14556 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14559 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14560 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14561 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14562 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14563 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14564 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14565 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14566 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14568 salt
->salt_len
= 32; // muss min. 32 haben
14570 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14571 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14572 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14573 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14574 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14576 return (PARSER_OK
);
14579 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14581 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14583 u32
*digest
= (u32
*) hash_buf
->digest
;
14585 salt_t
*salt
= hash_buf
->salt
;
14587 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14589 char *salt_pos
= input_buf
+ 1;
14591 memcpy (salt
->salt_buf
, salt_pos
, 8);
14593 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14594 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14596 salt
->salt_len
= 8;
14598 char *hash_pos
= salt_pos
+ 8;
14600 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14601 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14602 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14603 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14604 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14606 digest
[0] -= SHA1M_A
;
14607 digest
[1] -= SHA1M_B
;
14608 digest
[2] -= SHA1M_C
;
14609 digest
[3] -= SHA1M_D
;
14610 digest
[4] -= SHA1M_E
;
14612 return (PARSER_OK
);
14615 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14617 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14619 u32
*digest
= (u32
*) hash_buf
->digest
;
14621 salt_t
*salt
= hash_buf
->salt
;
14623 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14624 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14625 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14626 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14628 digest
[0] = byte_swap_32 (digest
[0]);
14629 digest
[1] = byte_swap_32 (digest
[1]);
14630 digest
[2] = byte_swap_32 (digest
[2]);
14631 digest
[3] = byte_swap_32 (digest
[3]);
14633 digest
[0] -= MD5M_A
;
14634 digest
[1] -= MD5M_B
;
14635 digest
[2] -= MD5M_C
;
14636 digest
[3] -= MD5M_D
;
14638 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14640 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14642 u32
*salt_buf
= salt
->salt_buf
;
14644 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14645 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14646 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14647 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14649 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14650 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14651 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14652 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14654 salt
->salt_len
= 16 + 1;
14656 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14658 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14660 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14662 return (PARSER_OK
);
14665 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14667 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14669 u32
*digest
= (u32
*) hash_buf
->digest
;
14671 salt_t
*salt
= hash_buf
->salt
;
14673 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14679 char *hashbuf_pos
= input_buf
;
14681 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14683 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14685 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14687 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14691 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14693 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14695 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14697 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14701 char *databuf_pos
= strchr (iteration_pos
, ':');
14703 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14705 const uint iteration_len
= databuf_pos
- iteration_pos
;
14707 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14708 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14710 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14712 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14713 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14719 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14720 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14721 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14722 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14723 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14724 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14725 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14726 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14730 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14732 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14734 const char p0
= saltbuf_pos
[i
+ 0];
14735 const char p1
= saltbuf_pos
[i
+ 1];
14737 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14738 | hex_convert (p0
) << 4;
14741 salt
->salt_buf
[4] = 0x01000000;
14742 salt
->salt_buf
[5] = 0x80;
14744 salt
->salt_len
= saltbuf_len
/ 2;
14748 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14752 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14754 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14756 const char p0
= databuf_pos
[i
+ 0];
14757 const char p1
= databuf_pos
[i
+ 1];
14759 *databuf_ptr
++ = hex_convert (p1
) << 0
14760 | hex_convert (p0
) << 4;
14763 *databuf_ptr
++ = 0x80;
14765 for (uint i
= 0; i
< 512; i
++)
14767 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14770 cloudkey
->data_len
= databuf_len
/ 2;
14772 return (PARSER_OK
);
14775 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14777 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14779 u32
*digest
= (u32
*) hash_buf
->digest
;
14781 salt_t
*salt
= hash_buf
->salt
;
14787 char *hashbuf_pos
= input_buf
;
14789 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14791 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14793 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14795 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14799 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14801 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14803 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14805 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14807 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14811 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14813 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14815 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14817 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14819 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14823 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14825 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14826 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14828 // ok, the plan for this algorithm is the following:
14829 // we have 2 salts here, the domain-name and a random salt
14830 // while both are used in the initial transformation,
14831 // only the random salt is used in the following iterations
14832 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14833 // and one that includes only the real salt (stored into salt_buf[]).
14834 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14836 u8 tmp_buf
[100] = { 0 };
14838 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14840 memcpy (digest
, tmp_buf
, 20);
14842 digest
[0] = byte_swap_32 (digest
[0]);
14843 digest
[1] = byte_swap_32 (digest
[1]);
14844 digest
[2] = byte_swap_32 (digest
[2]);
14845 digest
[3] = byte_swap_32 (digest
[3]);
14846 digest
[4] = byte_swap_32 (digest
[4]);
14850 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14852 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14854 char *len_ptr
= NULL
;
14856 for (uint i
= 0; i
< domainbuf_len
; i
++)
14858 if (salt_buf_pc_ptr
[i
] == '.')
14860 len_ptr
= &salt_buf_pc_ptr
[i
];
14870 salt
->salt_buf_pc
[7] = domainbuf_len
;
14874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14876 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14878 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14880 salt
->salt_len
= salt_len
;
14884 salt
->salt_iter
= atoi (iteration_pos
);
14886 return (PARSER_OK
);
14889 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14891 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14893 u32
*digest
= (u32
*) hash_buf
->digest
;
14895 salt_t
*salt
= hash_buf
->salt
;
14897 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14898 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14899 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14900 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14901 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14903 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 uint salt_len
= input_len
- 40 - 1;
14907 char *salt_buf
= input_buf
+ 40 + 1;
14909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14911 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14913 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14915 salt
->salt_len
= salt_len
;
14917 return (PARSER_OK
);
14920 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14922 const u8 ascii_to_ebcdic
[] =
14924 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14925 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14926 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14927 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14928 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14929 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14930 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14931 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14932 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14933 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14934 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14935 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14936 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14937 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14938 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14939 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14942 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14944 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14946 u32
*digest
= (u32
*) hash_buf
->digest
;
14948 salt_t
*salt
= hash_buf
->salt
;
14950 char *salt_pos
= input_buf
+ 6 + 1;
14952 char *digest_pos
= strchr (salt_pos
, '*');
14954 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 uint salt_len
= digest_pos
- salt_pos
;
14958 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14960 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14962 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14966 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14967 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14969 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14971 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14973 salt
->salt_len
= salt_len
;
14975 for (uint i
= 0; i
< salt_len
; i
++)
14977 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14979 for (uint i
= salt_len
; i
< 8; i
++)
14981 salt_buf_pc_ptr
[i
] = 0x40;
14986 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14988 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14989 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14991 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14992 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14994 digest
[0] = byte_swap_32 (digest
[0]);
14995 digest
[1] = byte_swap_32 (digest
[1]);
14997 IP (digest
[0], digest
[1], tt
);
14999 digest
[0] = rotr32 (digest
[0], 29);
15000 digest
[1] = rotr32 (digest
[1], 29);
15004 return (PARSER_OK
);
15007 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15009 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15011 u32
*digest
= (u32
*) hash_buf
->digest
;
15013 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15014 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15015 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15016 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15018 digest
[0] = byte_swap_32 (digest
[0]);
15019 digest
[1] = byte_swap_32 (digest
[1]);
15020 digest
[2] = byte_swap_32 (digest
[2]);
15021 digest
[3] = byte_swap_32 (digest
[3]);
15023 return (PARSER_OK
);
15026 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15028 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15030 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15032 u32
*digest
= (u32
*) hash_buf
->digest
;
15034 salt_t
*salt
= hash_buf
->salt
;
15036 u8 tmp_buf
[120] = { 0 };
15038 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15040 tmp_buf
[3] += -4; // dont ask!
15042 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15044 salt
->salt_len
= 5;
15046 memcpy (digest
, tmp_buf
+ 5, 9);
15048 // yes, only 9 byte are needed to crack, but 10 to display
15050 salt
->salt_buf_pc
[7] = input_buf
[20];
15052 return (PARSER_OK
);
15055 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15057 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15059 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15061 u32
*digest
= (u32
*) hash_buf
->digest
;
15063 salt_t
*salt
= hash_buf
->salt
;
15065 u8 tmp_buf
[120] = { 0 };
15067 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15069 tmp_buf
[3] += -4; // dont ask!
15073 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15075 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)
15079 char tmp_iter_buf
[11] = { 0 };
15081 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15083 tmp_iter_buf
[10] = 0;
15085 salt
->salt_iter
= atoi (tmp_iter_buf
);
15087 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15089 return (PARSER_SALT_ITERATION
);
15092 salt
->salt_iter
--; // first round in init
15094 // 2 additional bytes for display only
15096 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15097 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15101 memcpy (digest
, tmp_buf
+ 28, 8);
15103 digest
[0] = byte_swap_32 (digest
[0]);
15104 digest
[1] = byte_swap_32 (digest
[1]);
15108 return (PARSER_OK
);
15111 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15113 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15115 u32
*digest
= (u32
*) hash_buf
->digest
;
15117 salt_t
*salt
= hash_buf
->salt
;
15119 char *salt_buf_pos
= input_buf
;
15121 char *hash_buf_pos
= salt_buf_pos
+ 6;
15123 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15124 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15125 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15126 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15127 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15128 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15129 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15130 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15132 digest
[0] -= SHA256M_A
;
15133 digest
[1] -= SHA256M_B
;
15134 digest
[2] -= SHA256M_C
;
15135 digest
[3] -= SHA256M_D
;
15136 digest
[4] -= SHA256M_E
;
15137 digest
[5] -= SHA256M_F
;
15138 digest
[6] -= SHA256M_G
;
15139 digest
[7] -= SHA256M_H
;
15141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15143 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15147 salt
->salt_len
= salt_len
;
15149 return (PARSER_OK
);
15152 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15154 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15156 u32
*digest
= (u32
*) hash_buf
->digest
;
15158 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15160 salt_t
*salt
= hash_buf
->salt
;
15162 char *salt_buf
= input_buf
+ 6;
15164 char *digest_buf
= strchr (salt_buf
, '$');
15166 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15168 uint salt_len
= digest_buf
- salt_buf
;
15170 digest_buf
++; // skip the '$' symbol
15172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15178 salt
->salt_len
= salt_len
;
15180 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15181 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15182 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15183 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15185 digest
[0] = byte_swap_32 (digest
[0]);
15186 digest
[1] = byte_swap_32 (digest
[1]);
15187 digest
[2] = byte_swap_32 (digest
[2]);
15188 digest
[3] = byte_swap_32 (digest
[3]);
15190 digest
[0] -= MD5M_A
;
15191 digest
[1] -= MD5M_B
;
15192 digest
[2] -= MD5M_C
;
15193 digest
[3] -= MD5M_D
;
15195 return (PARSER_OK
);
15198 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15200 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15202 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15204 u32
*digest
= (u32
*) hash_buf
->digest
;
15206 salt_t
*salt
= hash_buf
->salt
;
15208 char *salt_buf
= input_buf
+ 3;
15210 char *digest_buf
= strchr (salt_buf
, '$');
15212 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15214 uint salt_len
= digest_buf
- salt_buf
;
15216 digest_buf
++; // skip the '$' symbol
15218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15220 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15222 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15224 salt_buf_ptr
[salt_len
] = 0x2d;
15226 salt
->salt_len
= salt_len
+ 1;
15228 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15229 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15230 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15231 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15233 digest
[0] = byte_swap_32 (digest
[0]);
15234 digest
[1] = byte_swap_32 (digest
[1]);
15235 digest
[2] = byte_swap_32 (digest
[2]);
15236 digest
[3] = byte_swap_32 (digest
[3]);
15238 digest
[0] -= MD5M_A
;
15239 digest
[1] -= MD5M_B
;
15240 digest
[2] -= MD5M_C
;
15241 digest
[3] -= MD5M_D
;
15243 return (PARSER_OK
);
15246 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15248 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15250 u32
*digest
= (u32
*) hash_buf
->digest
;
15252 salt_t
*salt
= hash_buf
->salt
;
15254 u8 tmp_buf
[100] = { 0 };
15256 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15258 memcpy (digest
, tmp_buf
, 20);
15260 digest
[0] = byte_swap_32 (digest
[0]);
15261 digest
[1] = byte_swap_32 (digest
[1]);
15262 digest
[2] = byte_swap_32 (digest
[2]);
15263 digest
[3] = byte_swap_32 (digest
[3]);
15264 digest
[4] = byte_swap_32 (digest
[4]);
15266 digest
[0] -= SHA1M_A
;
15267 digest
[1] -= SHA1M_B
;
15268 digest
[2] -= SHA1M_C
;
15269 digest
[3] -= SHA1M_D
;
15270 digest
[4] -= SHA1M_E
;
15272 salt
->salt_buf
[0] = 0x80;
15274 salt
->salt_len
= 0;
15276 return (PARSER_OK
);
15279 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15281 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15283 u32
*digest
= (u32
*) hash_buf
->digest
;
15285 salt_t
*salt
= hash_buf
->salt
;
15287 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15288 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15289 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15290 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15292 digest
[0] = byte_swap_32 (digest
[0]);
15293 digest
[1] = byte_swap_32 (digest
[1]);
15294 digest
[2] = byte_swap_32 (digest
[2]);
15295 digest
[3] = byte_swap_32 (digest
[3]);
15297 digest
[0] -= MD5M_A
;
15298 digest
[1] -= MD5M_B
;
15299 digest
[2] -= MD5M_C
;
15300 digest
[3] -= MD5M_D
;
15302 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15304 uint salt_len
= input_len
- 32 - 1;
15306 char *salt_buf
= input_buf
+ 32 + 1;
15308 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15310 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15312 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15315 * add static "salt" part
15318 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15322 salt
->salt_len
= salt_len
;
15324 return (PARSER_OK
);
15327 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15329 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15331 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15333 u32
*digest
= (u32
*) hash_buf
->digest
;
15335 salt_t
*salt
= hash_buf
->salt
;
15337 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15343 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15345 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15347 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15349 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15351 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15355 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15357 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15359 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15361 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15365 char *keybuf_pos
= strchr (keylen_pos
, '$');
15367 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15369 uint keylen_len
= keybuf_pos
- keylen_pos
;
15371 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15375 char *databuf_pos
= strchr (keybuf_pos
, '$');
15377 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15379 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15381 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15385 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15387 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15393 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15394 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15395 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15396 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15398 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15399 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15400 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15401 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15403 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15404 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15405 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15406 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15408 salt
->salt_len
= 16;
15409 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15411 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15413 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15416 return (PARSER_OK
);
15419 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15421 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15423 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15425 u32
*digest
= (u32
*) hash_buf
->digest
;
15427 salt_t
*salt
= hash_buf
->salt
;
15433 // first is the N salt parameter
15435 char *N_pos
= input_buf
+ 6;
15437 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15441 salt
->scrypt_N
= atoi (N_pos
);
15445 char *r_pos
= strchr (N_pos
, ':');
15447 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15451 salt
->scrypt_r
= atoi (r_pos
);
15455 char *p_pos
= strchr (r_pos
, ':');
15457 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15461 salt
->scrypt_p
= atoi (p_pos
);
15465 char *saltbuf_pos
= strchr (p_pos
, ':');
15467 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15471 char *hash_pos
= strchr (saltbuf_pos
, ':');
15473 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15479 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15481 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15483 u8 tmp_buf
[33] = { 0 };
15485 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15487 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15489 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15491 salt
->salt_len
= tmp_len
;
15492 salt
->salt_iter
= 1;
15494 // digest - base64 decode
15496 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15498 tmp_len
= input_len
- (hash_pos
- input_buf
);
15500 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15502 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15504 memcpy (digest
, tmp_buf
, 32);
15506 return (PARSER_OK
);
15509 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15511 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15513 u32
*digest
= (u32
*) hash_buf
->digest
;
15515 salt_t
*salt
= hash_buf
->salt
;
15521 char decrypted
[76] = { 0 }; // iv + hash
15523 juniper_decrypt_hash (input_buf
, decrypted
);
15525 char *md5crypt_hash
= decrypted
+ 12;
15527 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15529 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15531 char *salt_pos
= md5crypt_hash
+ 3;
15533 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15535 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15537 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15541 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15543 return (PARSER_OK
);
15546 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15548 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15550 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15552 u32
*digest
= (u32
*) hash_buf
->digest
;
15554 salt_t
*salt
= hash_buf
->salt
;
15556 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15562 // first is *raw* salt
15564 char *salt_pos
= input_buf
+ 3;
15566 char *hash_pos
= strchr (salt_pos
, '$');
15568 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15570 uint salt_len
= hash_pos
- salt_pos
;
15572 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15576 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15578 memcpy (salt_buf_ptr
, salt_pos
, 14);
15580 salt_buf_ptr
[17] = 0x01;
15581 salt_buf_ptr
[18] = 0x80;
15583 // add some stuff to normal salt to make sorted happy
15585 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15586 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15587 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15588 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15590 salt
->salt_len
= salt_len
;
15591 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15593 // base64 decode hash
15595 u8 tmp_buf
[100] = { 0 };
15597 uint hash_len
= input_len
- 3 - salt_len
- 1;
15599 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15601 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15603 memcpy (digest
, tmp_buf
, 32);
15605 digest
[0] = byte_swap_32 (digest
[0]);
15606 digest
[1] = byte_swap_32 (digest
[1]);
15607 digest
[2] = byte_swap_32 (digest
[2]);
15608 digest
[3] = byte_swap_32 (digest
[3]);
15609 digest
[4] = byte_swap_32 (digest
[4]);
15610 digest
[5] = byte_swap_32 (digest
[5]);
15611 digest
[6] = byte_swap_32 (digest
[6]);
15612 digest
[7] = byte_swap_32 (digest
[7]);
15614 return (PARSER_OK
);
15617 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15619 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15621 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15623 u32
*digest
= (u32
*) hash_buf
->digest
;
15625 salt_t
*salt
= hash_buf
->salt
;
15631 // first is *raw* salt
15633 char *salt_pos
= input_buf
+ 3;
15635 char *hash_pos
= strchr (salt_pos
, '$');
15637 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15639 uint salt_len
= hash_pos
- salt_pos
;
15641 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15643 salt
->salt_len
= salt_len
;
15646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15648 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15649 salt_buf_ptr
[salt_len
] = 0;
15651 // base64 decode hash
15653 u8 tmp_buf
[100] = { 0 };
15655 uint hash_len
= input_len
- 3 - salt_len
- 1;
15657 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15659 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15661 memcpy (digest
, tmp_buf
, 32);
15664 salt
->scrypt_N
= 16384;
15665 salt
->scrypt_r
= 1;
15666 salt
->scrypt_p
= 1;
15667 salt
->salt_iter
= 1;
15669 return (PARSER_OK
);
15672 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15674 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15676 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15678 u32
*digest
= (u32
*) hash_buf
->digest
;
15680 salt_t
*salt
= hash_buf
->salt
;
15682 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15688 char *version_pos
= input_buf
+ 8 + 1;
15690 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15692 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15694 u32 version_len
= verifierHashSize_pos
- version_pos
;
15696 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15698 verifierHashSize_pos
++;
15700 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15702 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15704 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15706 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15710 char *saltSize_pos
= strchr (keySize_pos
, '*');
15712 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15714 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15716 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15720 char *osalt_pos
= strchr (saltSize_pos
, '*');
15722 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15724 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15726 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15730 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15732 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15734 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15736 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15738 encryptedVerifier_pos
++;
15740 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15742 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15744 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15746 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15748 encryptedVerifierHash_pos
++;
15750 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;
15752 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15754 const uint version
= atoi (version_pos
);
15756 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15758 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15760 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15762 const uint keySize
= atoi (keySize_pos
);
15764 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15766 office2007
->keySize
= keySize
;
15768 const uint saltSize
= atoi (saltSize_pos
);
15770 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15776 salt
->salt_len
= 16;
15777 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15779 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15780 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15781 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15782 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15788 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15789 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15790 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15791 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15793 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15794 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15795 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15796 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15797 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15803 digest
[0] = office2007
->encryptedVerifierHash
[0];
15804 digest
[1] = office2007
->encryptedVerifierHash
[1];
15805 digest
[2] = office2007
->encryptedVerifierHash
[2];
15806 digest
[3] = office2007
->encryptedVerifierHash
[3];
15808 return (PARSER_OK
);
15811 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15813 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15815 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15817 u32
*digest
= (u32
*) hash_buf
->digest
;
15819 salt_t
*salt
= hash_buf
->salt
;
15821 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15827 char *version_pos
= input_buf
+ 8 + 1;
15829 char *spinCount_pos
= strchr (version_pos
, '*');
15831 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15833 u32 version_len
= spinCount_pos
- version_pos
;
15835 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15839 char *keySize_pos
= strchr (spinCount_pos
, '*');
15841 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15843 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15845 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15849 char *saltSize_pos
= strchr (keySize_pos
, '*');
15851 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15853 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15855 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15859 char *osalt_pos
= strchr (saltSize_pos
, '*');
15861 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15863 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15865 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15869 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15871 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15873 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15875 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15877 encryptedVerifier_pos
++;
15879 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15881 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15883 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15885 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15887 encryptedVerifierHash_pos
++;
15889 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;
15891 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15893 const uint version
= atoi (version_pos
);
15895 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15897 const uint spinCount
= atoi (spinCount_pos
);
15899 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15901 const uint keySize
= atoi (keySize_pos
);
15903 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15905 const uint saltSize
= atoi (saltSize_pos
);
15907 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15913 salt
->salt_len
= 16;
15914 salt
->salt_iter
= spinCount
;
15916 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15917 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15918 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15919 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15925 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15926 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15927 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15928 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15930 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15931 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15932 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15933 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15934 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15935 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15936 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15937 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15943 digest
[0] = office2010
->encryptedVerifierHash
[0];
15944 digest
[1] = office2010
->encryptedVerifierHash
[1];
15945 digest
[2] = office2010
->encryptedVerifierHash
[2];
15946 digest
[3] = office2010
->encryptedVerifierHash
[3];
15948 return (PARSER_OK
);
15951 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15953 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15955 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15957 u32
*digest
= (u32
*) hash_buf
->digest
;
15959 salt_t
*salt
= hash_buf
->salt
;
15961 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15967 char *version_pos
= input_buf
+ 8 + 1;
15969 char *spinCount_pos
= strchr (version_pos
, '*');
15971 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15973 u32 version_len
= spinCount_pos
- version_pos
;
15975 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15979 char *keySize_pos
= strchr (spinCount_pos
, '*');
15981 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15983 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15985 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15989 char *saltSize_pos
= strchr (keySize_pos
, '*');
15991 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15993 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15995 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15999 char *osalt_pos
= strchr (saltSize_pos
, '*');
16001 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16003 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16005 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16009 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16011 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16013 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16015 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16017 encryptedVerifier_pos
++;
16019 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16021 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16023 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16025 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16027 encryptedVerifierHash_pos
++;
16029 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;
16031 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16033 const uint version
= atoi (version_pos
);
16035 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16037 const uint spinCount
= atoi (spinCount_pos
);
16039 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16041 const uint keySize
= atoi (keySize_pos
);
16043 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16045 const uint saltSize
= atoi (saltSize_pos
);
16047 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16053 salt
->salt_len
= 16;
16054 salt
->salt_iter
= spinCount
;
16056 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16057 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16058 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16059 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16065 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16066 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16067 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16068 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16070 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16071 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16072 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16073 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16074 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16075 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16076 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16077 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16083 digest
[0] = office2013
->encryptedVerifierHash
[0];
16084 digest
[1] = office2013
->encryptedVerifierHash
[1];
16085 digest
[2] = office2013
->encryptedVerifierHash
[2];
16086 digest
[3] = office2013
->encryptedVerifierHash
[3];
16088 return (PARSER_OK
);
16091 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16093 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16095 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16097 u32
*digest
= (u32
*) hash_buf
->digest
;
16099 salt_t
*salt
= hash_buf
->salt
;
16101 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16107 char *version_pos
= input_buf
+ 11;
16109 char *osalt_pos
= strchr (version_pos
, '*');
16111 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16113 u32 version_len
= osalt_pos
- version_pos
;
16115 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16119 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16121 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16123 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16125 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16127 encryptedVerifier_pos
++;
16129 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16131 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16133 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16135 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16137 encryptedVerifierHash_pos
++;
16139 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16141 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16143 const uint version
= *version_pos
- 0x30;
16145 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16151 oldoffice01
->version
= version
;
16153 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16154 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16155 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16156 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16158 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16159 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16160 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16161 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16163 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16164 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16165 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16166 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16168 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16169 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16170 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16171 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16177 salt
->salt_len
= 16;
16179 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16180 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16181 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16182 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16184 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16185 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16186 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16187 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16189 // this is a workaround as office produces multiple documents with the same salt
16191 salt
->salt_len
+= 32;
16193 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16194 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16195 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16196 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16197 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16198 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16199 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16200 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16206 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16207 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16208 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16209 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16211 return (PARSER_OK
);
16214 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16216 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16219 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16221 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16223 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16225 u32
*digest
= (u32
*) hash_buf
->digest
;
16227 salt_t
*salt
= hash_buf
->salt
;
16229 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16235 char *version_pos
= input_buf
+ 11;
16237 char *osalt_pos
= strchr (version_pos
, '*');
16239 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16241 u32 version_len
= osalt_pos
- version_pos
;
16243 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16247 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16249 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16251 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16253 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16255 encryptedVerifier_pos
++;
16257 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16259 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16261 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16263 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16265 encryptedVerifierHash_pos
++;
16267 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16269 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16271 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16273 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16277 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16279 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16281 const uint version
= *version_pos
- 0x30;
16283 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16289 oldoffice01
->version
= version
;
16291 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16292 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16293 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16294 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16296 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16297 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16298 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16299 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16301 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16302 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16303 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16304 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16306 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16307 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16308 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16309 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16311 oldoffice01
->rc4key
[1] = 0;
16312 oldoffice01
->rc4key
[0] = 0;
16314 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16315 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16316 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16317 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16318 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16319 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16320 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16321 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16322 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16323 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16325 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16326 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16332 salt
->salt_len
= 16;
16334 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16335 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16336 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16337 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16339 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16340 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16341 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16342 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16344 // this is a workaround as office produces multiple documents with the same salt
16346 salt
->salt_len
+= 32;
16348 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16349 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16350 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16351 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16352 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16353 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16354 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16355 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16361 digest
[0] = oldoffice01
->rc4key
[0];
16362 digest
[1] = oldoffice01
->rc4key
[1];
16366 return (PARSER_OK
);
16369 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16371 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16373 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16375 u32
*digest
= (u32
*) hash_buf
->digest
;
16377 salt_t
*salt
= hash_buf
->salt
;
16379 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16385 char *version_pos
= input_buf
+ 11;
16387 char *osalt_pos
= strchr (version_pos
, '*');
16389 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16391 u32 version_len
= osalt_pos
- version_pos
;
16393 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16397 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16399 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16401 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16403 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16405 encryptedVerifier_pos
++;
16407 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16409 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16411 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16413 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16415 encryptedVerifierHash_pos
++;
16417 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16419 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16421 const uint version
= *version_pos
- 0x30;
16423 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16429 oldoffice34
->version
= version
;
16431 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16432 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16433 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16434 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16436 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16437 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16438 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16439 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16441 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16442 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16443 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16444 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16445 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16447 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16448 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16449 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16450 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16451 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16457 salt
->salt_len
= 16;
16459 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16460 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16461 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16462 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16464 // this is a workaround as office produces multiple documents with the same salt
16466 salt
->salt_len
+= 32;
16468 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16469 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16470 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16471 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16472 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16473 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16474 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16475 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16481 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16482 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16483 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16484 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16486 return (PARSER_OK
);
16489 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16491 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16493 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16496 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16498 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16500 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16502 u32
*digest
= (u32
*) hash_buf
->digest
;
16504 salt_t
*salt
= hash_buf
->salt
;
16506 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16512 char *version_pos
= input_buf
+ 11;
16514 char *osalt_pos
= strchr (version_pos
, '*');
16516 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16518 u32 version_len
= osalt_pos
- version_pos
;
16520 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16524 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16526 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16528 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16530 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16532 encryptedVerifier_pos
++;
16534 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16536 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16538 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16540 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16542 encryptedVerifierHash_pos
++;
16544 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16546 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16548 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16550 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16554 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16556 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16558 const uint version
= *version_pos
- 0x30;
16560 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16566 oldoffice34
->version
= version
;
16568 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16569 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16570 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16571 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16573 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16574 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16575 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16576 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16578 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16579 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16580 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16581 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16582 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16584 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16585 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16586 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16587 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16588 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16590 oldoffice34
->rc4key
[1] = 0;
16591 oldoffice34
->rc4key
[0] = 0;
16593 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16594 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16595 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16596 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16597 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16598 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16599 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16600 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16601 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16602 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16604 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16605 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16611 salt
->salt_len
= 16;
16613 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16614 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16615 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16616 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16618 // this is a workaround as office produces multiple documents with the same salt
16620 salt
->salt_len
+= 32;
16622 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16623 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16624 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16625 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16626 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16627 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16628 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16629 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16635 digest
[0] = oldoffice34
->rc4key
[0];
16636 digest
[1] = oldoffice34
->rc4key
[1];
16640 return (PARSER_OK
);
16643 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16645 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16647 u32
*digest
= (u32
*) hash_buf
->digest
;
16649 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16650 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16651 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16652 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16654 digest
[0] = byte_swap_32 (digest
[0]);
16655 digest
[1] = byte_swap_32 (digest
[1]);
16656 digest
[2] = byte_swap_32 (digest
[2]);
16657 digest
[3] = byte_swap_32 (digest
[3]);
16659 return (PARSER_OK
);
16662 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16664 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16666 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16668 u32
*digest
= (u32
*) hash_buf
->digest
;
16670 salt_t
*salt
= hash_buf
->salt
;
16672 char *signature_pos
= input_buf
;
16674 char *salt_pos
= strchr (signature_pos
, '$');
16676 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16678 u32 signature_len
= salt_pos
- signature_pos
;
16680 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16684 char *hash_pos
= strchr (salt_pos
, '$');
16686 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16688 u32 salt_len
= hash_pos
- salt_pos
;
16690 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16694 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16696 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16698 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16699 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16700 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16701 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16702 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16704 digest
[0] -= SHA1M_A
;
16705 digest
[1] -= SHA1M_B
;
16706 digest
[2] -= SHA1M_C
;
16707 digest
[3] -= SHA1M_D
;
16708 digest
[4] -= SHA1M_E
;
16710 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16712 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16714 salt
->salt_len
= salt_len
;
16716 return (PARSER_OK
);
16719 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16721 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16723 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16725 u32
*digest
= (u32
*) hash_buf
->digest
;
16727 salt_t
*salt
= hash_buf
->salt
;
16729 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16735 char *iter_pos
= input_buf
+ 14;
16737 const int iter
= atoi (iter_pos
);
16739 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16741 salt
->salt_iter
= iter
- 1;
16743 char *salt_pos
= strchr (iter_pos
, '$');
16745 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16749 char *hash_pos
= strchr (salt_pos
, '$');
16751 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16753 const uint salt_len
= hash_pos
- salt_pos
;
16757 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16759 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16761 salt
->salt_len
= salt_len
;
16763 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16764 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16766 // add some stuff to normal salt to make sorted happy
16768 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16769 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16770 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16771 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16772 salt
->salt_buf
[4] = salt
->salt_iter
;
16774 // base64 decode hash
16776 u8 tmp_buf
[100] = { 0 };
16778 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16780 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16782 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16784 memcpy (digest
, tmp_buf
, 32);
16786 digest
[0] = byte_swap_32 (digest
[0]);
16787 digest
[1] = byte_swap_32 (digest
[1]);
16788 digest
[2] = byte_swap_32 (digest
[2]);
16789 digest
[3] = byte_swap_32 (digest
[3]);
16790 digest
[4] = byte_swap_32 (digest
[4]);
16791 digest
[5] = byte_swap_32 (digest
[5]);
16792 digest
[6] = byte_swap_32 (digest
[6]);
16793 digest
[7] = byte_swap_32 (digest
[7]);
16795 return (PARSER_OK
);
16798 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16800 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16802 u32
*digest
= (u32
*) hash_buf
->digest
;
16804 salt_t
*salt
= hash_buf
->salt
;
16806 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16807 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16811 digest
[0] = byte_swap_32 (digest
[0]);
16812 digest
[1] = byte_swap_32 (digest
[1]);
16814 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16815 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16816 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16818 char iter_c
= input_buf
[17];
16819 char iter_d
= input_buf
[19];
16821 // atm only defaults, let's see if there's more request
16822 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16823 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16825 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16827 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16828 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16829 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16830 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16832 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16833 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16834 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16835 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16837 salt
->salt_len
= 16;
16839 return (PARSER_OK
);
16842 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16844 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16846 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16848 u32
*digest
= (u32
*) hash_buf
->digest
;
16850 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16852 salt_t
*salt
= hash_buf
->salt
;
16854 char *salt_pos
= input_buf
+ 10;
16856 char *hash_pos
= strchr (salt_pos
, '$');
16858 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16860 uint salt_len
= hash_pos
- salt_pos
;
16864 uint hash_len
= input_len
- 10 - salt_len
- 1;
16866 // base64 decode salt
16868 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16870 u8 tmp_buf
[100] = { 0 };
16872 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16874 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16876 tmp_buf
[salt_len
] = 0x80;
16878 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16880 salt
->salt_len
= salt_len
;
16882 // base64 decode hash
16884 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16886 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16888 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16890 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16892 uint user_len
= hash_len
- 32;
16894 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16896 user_len
--; // skip the trailing space
16898 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16899 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16900 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16901 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16903 digest
[0] = byte_swap_32 (digest
[0]);
16904 digest
[1] = byte_swap_32 (digest
[1]);
16905 digest
[2] = byte_swap_32 (digest
[2]);
16906 digest
[3] = byte_swap_32 (digest
[3]);
16908 // store username for host only (output hash if cracked)
16910 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16911 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16913 return (PARSER_OK
);
16916 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16918 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16920 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16922 u32
*digest
= (u32
*) hash_buf
->digest
;
16924 salt_t
*salt
= hash_buf
->salt
;
16926 char *iter_pos
= input_buf
+ 10;
16928 u32 iter
= atoi (iter_pos
);
16932 return (PARSER_SALT_ITERATION
);
16935 iter
--; // first iteration is special
16937 salt
->salt_iter
= iter
;
16939 char *base64_pos
= strchr (iter_pos
, '}');
16941 if (base64_pos
== NULL
)
16943 return (PARSER_SIGNATURE_UNMATCHED
);
16948 // base64 decode salt
16950 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16952 u8 tmp_buf
[100] = { 0 };
16954 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16956 if (decoded_len
< 24)
16958 return (PARSER_SALT_LENGTH
);
16963 uint salt_len
= decoded_len
- 20;
16965 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16966 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16968 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16970 salt
->salt_len
= salt_len
;
16974 u32
*digest_ptr
= (u32
*) tmp_buf
;
16976 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16977 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16978 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16979 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16980 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16982 return (PARSER_OK
);
16985 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16987 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16989 u32
*digest
= (u32
*) hash_buf
->digest
;
16991 salt_t
*salt
= hash_buf
->salt
;
16993 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16994 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16995 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16996 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16997 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16999 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17001 uint salt_len
= input_len
- 40 - 1;
17003 char *salt_buf
= input_buf
+ 40 + 1;
17005 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17007 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17009 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17011 salt
->salt_len
= salt_len
;
17013 return (PARSER_OK
);
17016 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17018 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17020 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17022 u32
*digest
= (u32
*) hash_buf
->digest
;
17024 salt_t
*salt
= hash_buf
->salt
;
17026 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17032 char *V_pos
= input_buf
+ 5;
17034 char *R_pos
= strchr (V_pos
, '*');
17036 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17038 u32 V_len
= R_pos
- V_pos
;
17042 char *bits_pos
= strchr (R_pos
, '*');
17044 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17046 u32 R_len
= bits_pos
- R_pos
;
17050 char *P_pos
= strchr (bits_pos
, '*');
17052 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17054 u32 bits_len
= P_pos
- bits_pos
;
17058 char *enc_md_pos
= strchr (P_pos
, '*');
17060 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17062 u32 P_len
= enc_md_pos
- P_pos
;
17066 char *id_len_pos
= strchr (enc_md_pos
, '*');
17068 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17074 char *id_buf_pos
= strchr (id_len_pos
, '*');
17076 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17078 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17082 char *u_len_pos
= strchr (id_buf_pos
, '*');
17084 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17086 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17088 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17092 char *u_buf_pos
= strchr (u_len_pos
, '*');
17094 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17096 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17100 char *o_len_pos
= strchr (u_buf_pos
, '*');
17102 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17104 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17106 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17110 char *o_buf_pos
= strchr (o_len_pos
, '*');
17112 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17114 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17118 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;
17120 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17124 const int V
= atoi (V_pos
);
17125 const int R
= atoi (R_pos
);
17126 const int P
= atoi (P_pos
);
17128 if (V
!= 1) return (PARSER_SALT_VALUE
);
17129 if (R
!= 2) return (PARSER_SALT_VALUE
);
17131 const int enc_md
= atoi (enc_md_pos
);
17133 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17135 const int id_len
= atoi (id_len_pos
);
17136 const int u_len
= atoi (u_len_pos
);
17137 const int o_len
= atoi (o_len_pos
);
17139 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17140 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17141 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17143 const int bits
= atoi (bits_pos
);
17145 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17147 // copy data to esalt
17153 pdf
->enc_md
= enc_md
;
17155 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17156 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17157 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17158 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17159 pdf
->id_len
= id_len
;
17161 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17162 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17163 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17164 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17165 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17166 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17167 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17168 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17169 pdf
->u_len
= u_len
;
17171 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17172 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17173 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17174 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17175 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17176 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17177 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17178 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17179 pdf
->o_len
= o_len
;
17181 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17182 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17183 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17184 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17186 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17187 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17188 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17189 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17190 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17191 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17192 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17193 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17195 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17196 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17197 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17198 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17199 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17200 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17201 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17202 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17204 // we use ID for salt, maybe needs to change, we will see...
17206 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17207 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17208 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17209 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17210 salt
->salt_len
= pdf
->id_len
;
17212 digest
[0] = pdf
->u_buf
[0];
17213 digest
[1] = pdf
->u_buf
[1];
17214 digest
[2] = pdf
->u_buf
[2];
17215 digest
[3] = pdf
->u_buf
[3];
17217 return (PARSER_OK
);
17220 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17222 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17225 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17227 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17229 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17231 u32
*digest
= (u32
*) hash_buf
->digest
;
17233 salt_t
*salt
= hash_buf
->salt
;
17235 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17241 char *V_pos
= input_buf
+ 5;
17243 char *R_pos
= strchr (V_pos
, '*');
17245 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17247 u32 V_len
= R_pos
- V_pos
;
17251 char *bits_pos
= strchr (R_pos
, '*');
17253 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17255 u32 R_len
= bits_pos
- R_pos
;
17259 char *P_pos
= strchr (bits_pos
, '*');
17261 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17263 u32 bits_len
= P_pos
- bits_pos
;
17267 char *enc_md_pos
= strchr (P_pos
, '*');
17269 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17271 u32 P_len
= enc_md_pos
- P_pos
;
17275 char *id_len_pos
= strchr (enc_md_pos
, '*');
17277 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17279 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17283 char *id_buf_pos
= strchr (id_len_pos
, '*');
17285 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17287 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17291 char *u_len_pos
= strchr (id_buf_pos
, '*');
17293 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17297 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17301 char *u_buf_pos
= strchr (u_len_pos
, '*');
17303 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17305 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17309 char *o_len_pos
= strchr (u_buf_pos
, '*');
17311 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17313 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17315 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17319 char *o_buf_pos
= strchr (o_len_pos
, '*');
17321 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17323 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17327 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17329 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17331 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17333 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17337 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;
17339 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17343 const int V
= atoi (V_pos
);
17344 const int R
= atoi (R_pos
);
17345 const int P
= atoi (P_pos
);
17347 if (V
!= 1) return (PARSER_SALT_VALUE
);
17348 if (R
!= 2) return (PARSER_SALT_VALUE
);
17350 const int enc_md
= atoi (enc_md_pos
);
17352 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17354 const int id_len
= atoi (id_len_pos
);
17355 const int u_len
= atoi (u_len_pos
);
17356 const int o_len
= atoi (o_len_pos
);
17358 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17359 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17360 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17362 const int bits
= atoi (bits_pos
);
17364 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17366 // copy data to esalt
17372 pdf
->enc_md
= enc_md
;
17374 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17375 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17376 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17377 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17378 pdf
->id_len
= id_len
;
17380 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17381 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17382 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17383 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17384 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17385 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17386 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17387 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17388 pdf
->u_len
= u_len
;
17390 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17391 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17392 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17393 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17394 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17395 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17396 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17397 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17398 pdf
->o_len
= o_len
;
17400 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17401 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17402 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17403 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17405 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17406 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17407 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17408 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17409 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17410 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17411 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17412 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17414 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17415 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17416 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17417 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17418 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17419 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17420 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17421 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17423 pdf
->rc4key
[1] = 0;
17424 pdf
->rc4key
[0] = 0;
17426 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17427 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17428 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17429 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17430 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17431 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17432 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17433 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17434 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17435 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17437 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17438 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17440 // we use ID for salt, maybe needs to change, we will see...
17442 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17443 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17444 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17445 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17446 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17447 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17448 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17449 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17450 salt
->salt_len
= pdf
->id_len
+ 16;
17452 digest
[0] = pdf
->rc4key
[0];
17453 digest
[1] = pdf
->rc4key
[1];
17457 return (PARSER_OK
);
17460 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17462 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17464 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17466 u32
*digest
= (u32
*) hash_buf
->digest
;
17468 salt_t
*salt
= hash_buf
->salt
;
17470 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17476 char *V_pos
= input_buf
+ 5;
17478 char *R_pos
= strchr (V_pos
, '*');
17480 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17482 u32 V_len
= R_pos
- V_pos
;
17486 char *bits_pos
= strchr (R_pos
, '*');
17488 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17490 u32 R_len
= bits_pos
- R_pos
;
17494 char *P_pos
= strchr (bits_pos
, '*');
17496 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17498 u32 bits_len
= P_pos
- bits_pos
;
17502 char *enc_md_pos
= strchr (P_pos
, '*');
17504 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17506 u32 P_len
= enc_md_pos
- P_pos
;
17510 char *id_len_pos
= strchr (enc_md_pos
, '*');
17512 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17514 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17518 char *id_buf_pos
= strchr (id_len_pos
, '*');
17520 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17522 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17526 char *u_len_pos
= strchr (id_buf_pos
, '*');
17528 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17530 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17532 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17536 char *u_buf_pos
= strchr (u_len_pos
, '*');
17538 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17540 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17544 char *o_len_pos
= strchr (u_buf_pos
, '*');
17546 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17548 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17550 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17554 char *o_buf_pos
= strchr (o_len_pos
, '*');
17556 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17558 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17562 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;
17564 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17568 const int V
= atoi (V_pos
);
17569 const int R
= atoi (R_pos
);
17570 const int P
= atoi (P_pos
);
17574 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17575 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17577 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17579 const int id_len
= atoi (id_len_pos
);
17580 const int u_len
= atoi (u_len_pos
);
17581 const int o_len
= atoi (o_len_pos
);
17583 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17585 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17586 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17588 const int bits
= atoi (bits_pos
);
17590 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17596 enc_md
= atoi (enc_md_pos
);
17599 // copy data to esalt
17605 pdf
->enc_md
= enc_md
;
17607 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17608 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17609 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17610 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17614 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17615 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17616 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17617 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17620 pdf
->id_len
= id_len
;
17622 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17623 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17624 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17625 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17626 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17627 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17628 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17629 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17630 pdf
->u_len
= u_len
;
17632 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17633 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17634 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17635 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17636 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17637 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17638 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17639 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17640 pdf
->o_len
= o_len
;
17642 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17643 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17644 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17645 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17649 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17650 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17651 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17652 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17655 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17656 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17657 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17658 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17659 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17660 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17661 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17662 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17664 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17665 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17666 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17667 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17668 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17669 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17670 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17671 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17673 // precompute rc4 data for later use
17689 uint salt_pc_block
[32] = { 0 };
17691 char *salt_pc_ptr
= (char *) salt_pc_block
;
17693 memcpy (salt_pc_ptr
, padding
, 32);
17694 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17696 uint salt_pc_digest
[4] = { 0 };
17698 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17700 pdf
->rc4data
[0] = salt_pc_digest
[0];
17701 pdf
->rc4data
[1] = salt_pc_digest
[1];
17703 // we use ID for salt, maybe needs to change, we will see...
17705 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17706 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17707 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17708 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17709 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17710 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17711 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17712 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17713 salt
->salt_len
= pdf
->id_len
+ 16;
17715 salt
->salt_iter
= ROUNDS_PDF14
;
17717 digest
[0] = pdf
->u_buf
[0];
17718 digest
[1] = pdf
->u_buf
[1];
17722 return (PARSER_OK
);
17725 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17727 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17729 if (ret
!= PARSER_OK
)
17734 u32
*digest
= (u32
*) hash_buf
->digest
;
17736 salt_t
*salt
= hash_buf
->salt
;
17738 digest
[0] -= SHA256M_A
;
17739 digest
[1] -= SHA256M_B
;
17740 digest
[2] -= SHA256M_C
;
17741 digest
[3] -= SHA256M_D
;
17742 digest
[4] -= SHA256M_E
;
17743 digest
[5] -= SHA256M_F
;
17744 digest
[6] -= SHA256M_G
;
17745 digest
[7] -= SHA256M_H
;
17747 salt
->salt_buf
[2] = 0x80;
17749 return (PARSER_OK
);
17752 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17754 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17756 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17758 u32
*digest
= (u32
*) hash_buf
->digest
;
17760 salt_t
*salt
= hash_buf
->salt
;
17762 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17768 char *V_pos
= input_buf
+ 5;
17770 char *R_pos
= strchr (V_pos
, '*');
17772 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17774 u32 V_len
= R_pos
- V_pos
;
17778 char *bits_pos
= strchr (R_pos
, '*');
17780 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17782 u32 R_len
= bits_pos
- R_pos
;
17786 char *P_pos
= strchr (bits_pos
, '*');
17788 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17790 u32 bits_len
= P_pos
- bits_pos
;
17794 char *enc_md_pos
= strchr (P_pos
, '*');
17796 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17798 u32 P_len
= enc_md_pos
- P_pos
;
17802 char *id_len_pos
= strchr (enc_md_pos
, '*');
17804 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17806 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17810 char *id_buf_pos
= strchr (id_len_pos
, '*');
17812 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17814 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17818 char *u_len_pos
= strchr (id_buf_pos
, '*');
17820 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17822 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17826 char *u_buf_pos
= strchr (u_len_pos
, '*');
17828 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17830 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17834 char *o_len_pos
= strchr (u_buf_pos
, '*');
17836 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17838 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17842 char *o_buf_pos
= strchr (o_len_pos
, '*');
17844 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17846 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17850 char *last
= strchr (o_buf_pos
, '*');
17852 if (last
== NULL
) last
= input_buf
+ input_len
;
17854 u32 o_buf_len
= last
- o_buf_pos
;
17858 const int V
= atoi (V_pos
);
17859 const int R
= atoi (R_pos
);
17863 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17864 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17866 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17868 const int bits
= atoi (bits_pos
);
17870 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17872 int enc_md
= atoi (enc_md_pos
);
17874 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17876 const uint id_len
= atoi (id_len_pos
);
17877 const uint u_len
= atoi (u_len_pos
);
17878 const uint o_len
= atoi (o_len_pos
);
17880 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17881 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17882 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17883 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17884 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17885 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17886 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17887 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17889 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17890 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17891 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17893 // copy data to esalt
17895 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17897 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17899 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17902 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17903 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17905 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17906 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17908 salt
->salt_len
= 8;
17909 salt
->salt_iter
= ROUNDS_PDF17L8
;
17911 digest
[0] = pdf
->u_buf
[0];
17912 digest
[1] = pdf
->u_buf
[1];
17913 digest
[2] = pdf
->u_buf
[2];
17914 digest
[3] = pdf
->u_buf
[3];
17915 digest
[4] = pdf
->u_buf
[4];
17916 digest
[5] = pdf
->u_buf
[5];
17917 digest
[6] = pdf
->u_buf
[6];
17918 digest
[7] = pdf
->u_buf
[7];
17920 return (PARSER_OK
);
17923 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17925 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17927 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17929 u32
*digest
= (u32
*) hash_buf
->digest
;
17931 salt_t
*salt
= hash_buf
->salt
;
17933 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17941 char *iter_pos
= input_buf
+ 7;
17943 u32 iter
= atoi (iter_pos
);
17945 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17946 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17948 // first is *raw* salt
17950 char *salt_pos
= strchr (iter_pos
, ':');
17952 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17956 char *hash_pos
= strchr (salt_pos
, ':');
17958 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17960 u32 salt_len
= hash_pos
- salt_pos
;
17962 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17966 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17968 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17972 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17974 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17978 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17979 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17981 salt
->salt_len
= salt_len
;
17982 salt
->salt_iter
= iter
- 1;
17986 u8 tmp_buf
[100] = { 0 };
17988 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17990 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17992 memcpy (digest
, tmp_buf
, 16);
17994 digest
[0] = byte_swap_32 (digest
[0]);
17995 digest
[1] = byte_swap_32 (digest
[1]);
17996 digest
[2] = byte_swap_32 (digest
[2]);
17997 digest
[3] = byte_swap_32 (digest
[3]);
17999 // add some stuff to normal salt to make sorted happy
18001 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18002 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18003 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18004 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18005 salt
->salt_buf
[4] = salt
->salt_iter
;
18007 return (PARSER_OK
);
18010 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18012 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18014 u32
*digest
= (u32
*) hash_buf
->digest
;
18016 salt_t
*salt
= hash_buf
->salt
;
18018 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18019 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18020 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18021 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18023 digest
[0] = byte_swap_32 (digest
[0]);
18024 digest
[1] = byte_swap_32 (digest
[1]);
18025 digest
[2] = byte_swap_32 (digest
[2]);
18026 digest
[3] = byte_swap_32 (digest
[3]);
18028 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18030 uint salt_len
= input_len
- 32 - 1;
18032 char *salt_buf
= input_buf
+ 32 + 1;
18034 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18036 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18038 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18040 salt
->salt_len
= salt_len
;
18042 return (PARSER_OK
);
18045 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18047 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18049 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18051 u32
*digest
= (u32
*) hash_buf
->digest
;
18053 salt_t
*salt
= hash_buf
->salt
;
18055 char *user_pos
= input_buf
+ 10;
18057 char *salt_pos
= strchr (user_pos
, '*');
18059 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18063 char *hash_pos
= strchr (salt_pos
, '*');
18067 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18069 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18071 uint user_len
= salt_pos
- user_pos
- 1;
18073 uint salt_len
= hash_pos
- salt_pos
- 1;
18075 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18081 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18082 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18083 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18084 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18086 digest
[0] = byte_swap_32 (digest
[0]);
18087 digest
[1] = byte_swap_32 (digest
[1]);
18088 digest
[2] = byte_swap_32 (digest
[2]);
18089 digest
[3] = byte_swap_32 (digest
[3]);
18091 digest
[0] -= MD5M_A
;
18092 digest
[1] -= MD5M_B
;
18093 digest
[2] -= MD5M_C
;
18094 digest
[3] -= MD5M_D
;
18100 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18102 // first 4 bytes are the "challenge"
18104 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18105 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18106 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18107 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18109 // append the user name
18111 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18113 salt
->salt_len
= 4 + user_len
;
18115 return (PARSER_OK
);
18118 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18120 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18122 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18124 u32
*digest
= (u32
*) hash_buf
->digest
;
18126 salt_t
*salt
= hash_buf
->salt
;
18128 char *salt_pos
= input_buf
+ 9;
18130 char *hash_pos
= strchr (salt_pos
, '*');
18132 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18136 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18138 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18140 uint salt_len
= hash_pos
- salt_pos
- 1;
18142 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18148 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18149 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18150 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18151 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18152 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18162 salt
->salt_len
= salt_len
;
18164 return (PARSER_OK
);
18167 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18169 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18171 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18173 u32
*digest
= (u32
*) hash_buf
->digest
;
18175 salt_t
*salt
= hash_buf
->salt
;
18177 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18183 char *cry_master_len_pos
= input_buf
+ 9;
18185 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18187 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18189 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18191 cry_master_buf_pos
++;
18193 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18195 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18197 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18199 cry_salt_len_pos
++;
18201 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18203 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18205 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18207 cry_salt_buf_pos
++;
18209 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18211 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18213 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18217 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18219 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18221 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18225 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18227 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18229 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18233 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18235 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18237 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18239 public_key_len_pos
++;
18241 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18243 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18245 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18247 public_key_buf_pos
++;
18249 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;
18251 const uint cry_master_len
= atoi (cry_master_len_pos
);
18252 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18253 const uint ckey_len
= atoi (ckey_len_pos
);
18254 const uint public_key_len
= atoi (public_key_len_pos
);
18256 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18257 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18258 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18259 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18261 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18263 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18265 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18268 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18270 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18272 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18275 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18277 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18279 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18282 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18283 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18284 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18287 * store digest (should be unique enought, hopefully)
18290 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18291 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18292 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18293 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18299 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18301 const uint cry_rounds
= atoi (cry_rounds_pos
);
18303 salt
->salt_iter
= cry_rounds
- 1;
18305 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18307 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18309 salt
->salt_len
= salt_len
;
18311 return (PARSER_OK
);
18314 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18316 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18318 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18320 u32
*digest
= (u32
*) hash_buf
->digest
;
18322 salt_t
*salt
= hash_buf
->salt
;
18324 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18326 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18328 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18330 memcpy (temp_input_buf
, input_buf
, input_len
);
18334 char *URI_server_pos
= temp_input_buf
+ 6;
18336 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18338 if (URI_client_pos
== NULL
)
18340 myfree (temp_input_buf
);
18342 return (PARSER_SEPARATOR_UNMATCHED
);
18345 URI_client_pos
[0] = 0;
18348 uint URI_server_len
= strlen (URI_server_pos
);
18350 if (URI_server_len
> 512)
18352 myfree (temp_input_buf
);
18354 return (PARSER_SALT_LENGTH
);
18359 char *user_pos
= strchr (URI_client_pos
, '*');
18361 if (user_pos
== NULL
)
18363 myfree (temp_input_buf
);
18365 return (PARSER_SEPARATOR_UNMATCHED
);
18371 uint URI_client_len
= strlen (URI_client_pos
);
18373 if (URI_client_len
> 512)
18375 myfree (temp_input_buf
);
18377 return (PARSER_SALT_LENGTH
);
18382 char *realm_pos
= strchr (user_pos
, '*');
18384 if (realm_pos
== NULL
)
18386 myfree (temp_input_buf
);
18388 return (PARSER_SEPARATOR_UNMATCHED
);
18394 uint user_len
= strlen (user_pos
);
18396 if (user_len
> 116)
18398 myfree (temp_input_buf
);
18400 return (PARSER_SALT_LENGTH
);
18405 char *method_pos
= strchr (realm_pos
, '*');
18407 if (method_pos
== NULL
)
18409 myfree (temp_input_buf
);
18411 return (PARSER_SEPARATOR_UNMATCHED
);
18417 uint realm_len
= strlen (realm_pos
);
18419 if (realm_len
> 116)
18421 myfree (temp_input_buf
);
18423 return (PARSER_SALT_LENGTH
);
18428 char *URI_prefix_pos
= strchr (method_pos
, '*');
18430 if (URI_prefix_pos
== NULL
)
18432 myfree (temp_input_buf
);
18434 return (PARSER_SEPARATOR_UNMATCHED
);
18437 URI_prefix_pos
[0] = 0;
18440 uint method_len
= strlen (method_pos
);
18442 if (method_len
> 246)
18444 myfree (temp_input_buf
);
18446 return (PARSER_SALT_LENGTH
);
18451 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18453 if (URI_resource_pos
== NULL
)
18455 myfree (temp_input_buf
);
18457 return (PARSER_SEPARATOR_UNMATCHED
);
18460 URI_resource_pos
[0] = 0;
18461 URI_resource_pos
++;
18463 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18465 if (URI_prefix_len
> 245)
18467 myfree (temp_input_buf
);
18469 return (PARSER_SALT_LENGTH
);
18474 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18476 if (URI_suffix_pos
== NULL
)
18478 myfree (temp_input_buf
);
18480 return (PARSER_SEPARATOR_UNMATCHED
);
18483 URI_suffix_pos
[0] = 0;
18486 uint URI_resource_len
= strlen (URI_resource_pos
);
18488 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18490 myfree (temp_input_buf
);
18492 return (PARSER_SALT_LENGTH
);
18497 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18499 if (nonce_pos
== NULL
)
18501 myfree (temp_input_buf
);
18503 return (PARSER_SEPARATOR_UNMATCHED
);
18509 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18511 if (URI_suffix_len
> 245)
18513 myfree (temp_input_buf
);
18515 return (PARSER_SALT_LENGTH
);
18520 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18522 if (nonce_client_pos
== NULL
)
18524 myfree (temp_input_buf
);
18526 return (PARSER_SEPARATOR_UNMATCHED
);
18529 nonce_client_pos
[0] = 0;
18530 nonce_client_pos
++;
18532 uint nonce_len
= strlen (nonce_pos
);
18534 if (nonce_len
< 1 || nonce_len
> 50)
18536 myfree (temp_input_buf
);
18538 return (PARSER_SALT_LENGTH
);
18543 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18545 if (nonce_count_pos
== NULL
)
18547 myfree (temp_input_buf
);
18549 return (PARSER_SEPARATOR_UNMATCHED
);
18552 nonce_count_pos
[0] = 0;
18555 uint nonce_client_len
= strlen (nonce_client_pos
);
18557 if (nonce_client_len
> 50)
18559 myfree (temp_input_buf
);
18561 return (PARSER_SALT_LENGTH
);
18566 char *qop_pos
= strchr (nonce_count_pos
, '*');
18568 if (qop_pos
== NULL
)
18570 myfree (temp_input_buf
);
18572 return (PARSER_SEPARATOR_UNMATCHED
);
18578 uint nonce_count_len
= strlen (nonce_count_pos
);
18580 if (nonce_count_len
> 50)
18582 myfree (temp_input_buf
);
18584 return (PARSER_SALT_LENGTH
);
18589 char *directive_pos
= strchr (qop_pos
, '*');
18591 if (directive_pos
== NULL
)
18593 myfree (temp_input_buf
);
18595 return (PARSER_SEPARATOR_UNMATCHED
);
18598 directive_pos
[0] = 0;
18601 uint qop_len
= strlen (qop_pos
);
18605 myfree (temp_input_buf
);
18607 return (PARSER_SALT_LENGTH
);
18612 char *digest_pos
= strchr (directive_pos
, '*');
18614 if (digest_pos
== NULL
)
18616 myfree (temp_input_buf
);
18618 return (PARSER_SEPARATOR_UNMATCHED
);
18624 uint directive_len
= strlen (directive_pos
);
18626 if (directive_len
!= 3)
18628 myfree (temp_input_buf
);
18630 return (PARSER_SALT_LENGTH
);
18633 if (memcmp (directive_pos
, "MD5", 3))
18635 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18637 myfree (temp_input_buf
);
18639 return (PARSER_SIP_AUTH_DIRECTIVE
);
18643 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18648 uint md5_max_len
= 4 * 64;
18650 uint md5_remaining_len
= md5_max_len
;
18652 uint tmp_md5_buf
[64] = { 0 };
18654 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18656 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18658 md5_len
+= method_len
+ 1;
18659 tmp_md5_ptr
+= method_len
+ 1;
18661 if (URI_prefix_len
> 0)
18663 md5_remaining_len
= md5_max_len
- md5_len
;
18665 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18667 md5_len
+= URI_prefix_len
+ 1;
18668 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18671 md5_remaining_len
= md5_max_len
- md5_len
;
18673 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18675 md5_len
+= URI_resource_len
;
18676 tmp_md5_ptr
+= URI_resource_len
;
18678 if (URI_suffix_len
> 0)
18680 md5_remaining_len
= md5_max_len
- md5_len
;
18682 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18684 md5_len
+= 1 + URI_suffix_len
;
18687 uint tmp_digest
[4] = { 0 };
18689 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18691 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18692 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18693 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18694 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18700 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18702 uint esalt_len
= 0;
18704 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18706 // there are 2 possibilities for the esalt:
18708 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18710 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18712 if (esalt_len
> max_esalt_len
)
18714 myfree (temp_input_buf
);
18716 return (PARSER_SALT_LENGTH
);
18719 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18731 esalt_len
= 1 + nonce_len
+ 1 + 32;
18733 if (esalt_len
> max_esalt_len
)
18735 myfree (temp_input_buf
);
18737 return (PARSER_SALT_LENGTH
);
18740 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18748 // add 0x80 to esalt
18750 esalt_buf_ptr
[esalt_len
] = 0x80;
18752 sip
->esalt_len
= esalt_len
;
18758 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18760 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18762 uint max_salt_len
= 119;
18764 if (salt_len
> max_salt_len
)
18766 myfree (temp_input_buf
);
18768 return (PARSER_SALT_LENGTH
);
18771 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18773 sip
->salt_len
= salt_len
;
18776 * fake salt (for sorting)
18779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18783 uint fake_salt_len
= salt_len
;
18785 if (fake_salt_len
> max_salt_len
)
18787 fake_salt_len
= max_salt_len
;
18790 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18792 salt
->salt_len
= fake_salt_len
;
18798 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18799 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18800 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18801 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18803 digest
[0] = byte_swap_32 (digest
[0]);
18804 digest
[1] = byte_swap_32 (digest
[1]);
18805 digest
[2] = byte_swap_32 (digest
[2]);
18806 digest
[3] = byte_swap_32 (digest
[3]);
18808 myfree (temp_input_buf
);
18810 return (PARSER_OK
);
18813 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18815 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18817 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18819 u32
*digest
= (u32
*) hash_buf
->digest
;
18821 salt_t
*salt
= hash_buf
->salt
;
18825 char *digest_pos
= input_buf
;
18827 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18834 char *salt_buf
= input_buf
+ 8 + 1;
18838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18840 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18842 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18844 salt
->salt_len
= salt_len
;
18846 return (PARSER_OK
);
18849 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18851 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18853 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18855 u32
*digest
= (u32
*) hash_buf
->digest
;
18857 salt_t
*salt
= hash_buf
->salt
;
18859 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18865 char *p_buf_pos
= input_buf
+ 4;
18867 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18869 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18871 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18873 NumCyclesPower_pos
++;
18875 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18877 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18879 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18883 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18885 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18887 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18891 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18893 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18895 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18899 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18901 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18903 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18907 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18909 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18911 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18915 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18917 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18919 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18923 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18925 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18927 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18931 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18933 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18935 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18939 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;
18941 const uint iter
= atoi (NumCyclesPower_pos
);
18942 const uint crc
= atoi (crc_buf_pos
);
18943 const uint p_buf
= atoi (p_buf_pos
);
18944 const uint salt_len
= atoi (salt_len_pos
);
18945 const uint iv_len
= atoi (iv_len_pos
);
18946 const uint unpack_size
= atoi (unpack_size_pos
);
18947 const uint data_len
= atoi (data_len_pos
);
18953 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18954 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18956 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18958 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18960 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18966 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18967 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18968 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18969 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18971 seven_zip
->iv_len
= iv_len
;
18973 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18975 seven_zip
->salt_len
= 0;
18977 seven_zip
->crc
= crc
;
18979 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18981 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18983 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18986 seven_zip
->data_len
= data_len
;
18988 seven_zip
->unpack_size
= unpack_size
;
18992 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18993 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18994 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18995 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18997 salt
->salt_len
= 16;
18999 salt
->salt_sign
[0] = iter
;
19001 salt
->salt_iter
= 1 << iter
;
19012 return (PARSER_OK
);
19015 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19017 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19019 u32
*digest
= (u32
*) hash_buf
->digest
;
19021 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19022 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19023 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19024 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19025 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19026 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19027 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19028 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19030 digest
[0] = byte_swap_32 (digest
[0]);
19031 digest
[1] = byte_swap_32 (digest
[1]);
19032 digest
[2] = byte_swap_32 (digest
[2]);
19033 digest
[3] = byte_swap_32 (digest
[3]);
19034 digest
[4] = byte_swap_32 (digest
[4]);
19035 digest
[5] = byte_swap_32 (digest
[5]);
19036 digest
[6] = byte_swap_32 (digest
[6]);
19037 digest
[7] = byte_swap_32 (digest
[7]);
19039 return (PARSER_OK
);
19042 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19044 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19046 u32
*digest
= (u32
*) hash_buf
->digest
;
19048 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19049 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19050 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19051 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19052 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19053 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19054 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19055 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19056 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19057 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19058 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19059 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19060 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19061 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19062 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19063 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19065 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19066 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19067 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19068 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19069 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19070 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19071 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19072 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19073 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19074 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19075 digest
[10] = byte_swap_32 (digest
[10]);
19076 digest
[11] = byte_swap_32 (digest
[11]);
19077 digest
[12] = byte_swap_32 (digest
[12]);
19078 digest
[13] = byte_swap_32 (digest
[13]);
19079 digest
[14] = byte_swap_32 (digest
[14]);
19080 digest
[15] = byte_swap_32 (digest
[15]);
19082 return (PARSER_OK
);
19085 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19087 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19089 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19091 u32
*digest
= (u32
*) hash_buf
->digest
;
19093 salt_t
*salt
= hash_buf
->salt
;
19095 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19103 char *iter_pos
= input_buf
+ 4;
19105 u32 iter
= atoi (iter_pos
);
19107 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19108 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19110 // first is *raw* salt
19112 char *salt_pos
= strchr (iter_pos
, ':');
19114 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19118 char *hash_pos
= strchr (salt_pos
, ':');
19120 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19122 u32 salt_len
= hash_pos
- salt_pos
;
19124 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19128 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19130 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19134 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19136 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19138 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19140 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19141 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19143 salt
->salt_len
= salt_len
;
19144 salt
->salt_iter
= iter
- 1;
19148 u8 tmp_buf
[100] = { 0 };
19150 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19152 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19154 memcpy (digest
, tmp_buf
, 16);
19156 // add some stuff to normal salt to make sorted happy
19158 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19159 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19160 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19161 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19162 salt
->salt_buf
[4] = salt
->salt_iter
;
19164 return (PARSER_OK
);
19167 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19169 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19171 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19173 u32
*digest
= (u32
*) hash_buf
->digest
;
19175 salt_t
*salt
= hash_buf
->salt
;
19177 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19185 char *iter_pos
= input_buf
+ 5;
19187 u32 iter
= atoi (iter_pos
);
19189 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19190 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19192 // first is *raw* salt
19194 char *salt_pos
= strchr (iter_pos
, ':');
19196 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19200 char *hash_pos
= strchr (salt_pos
, ':');
19202 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19204 u32 salt_len
= hash_pos
- salt_pos
;
19206 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19210 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19212 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19216 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19218 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19220 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19222 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19223 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19225 salt
->salt_len
= salt_len
;
19226 salt
->salt_iter
= iter
- 1;
19230 u8 tmp_buf
[100] = { 0 };
19232 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19234 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19236 memcpy (digest
, tmp_buf
, 16);
19238 digest
[0] = byte_swap_32 (digest
[0]);
19239 digest
[1] = byte_swap_32 (digest
[1]);
19240 digest
[2] = byte_swap_32 (digest
[2]);
19241 digest
[3] = byte_swap_32 (digest
[3]);
19243 // add some stuff to normal salt to make sorted happy
19245 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19246 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19247 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19248 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19249 salt
->salt_buf
[4] = salt
->salt_iter
;
19251 return (PARSER_OK
);
19254 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19256 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19258 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19260 u64
*digest
= (u64
*) hash_buf
->digest
;
19262 salt_t
*salt
= hash_buf
->salt
;
19264 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19272 char *iter_pos
= input_buf
+ 7;
19274 u32 iter
= atoi (iter_pos
);
19276 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19277 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19279 // first is *raw* salt
19281 char *salt_pos
= strchr (iter_pos
, ':');
19283 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19287 char *hash_pos
= strchr (salt_pos
, ':');
19289 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19291 u32 salt_len
= hash_pos
- salt_pos
;
19293 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19297 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19299 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19303 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19305 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19307 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19309 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19310 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19312 salt
->salt_len
= salt_len
;
19313 salt
->salt_iter
= iter
- 1;
19317 u8 tmp_buf
[100] = { 0 };
19319 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19321 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19323 memcpy (digest
, tmp_buf
, 64);
19325 digest
[0] = byte_swap_64 (digest
[0]);
19326 digest
[1] = byte_swap_64 (digest
[1]);
19327 digest
[2] = byte_swap_64 (digest
[2]);
19328 digest
[3] = byte_swap_64 (digest
[3]);
19329 digest
[4] = byte_swap_64 (digest
[4]);
19330 digest
[5] = byte_swap_64 (digest
[5]);
19331 digest
[6] = byte_swap_64 (digest
[6]);
19332 digest
[7] = byte_swap_64 (digest
[7]);
19334 // add some stuff to normal salt to make sorted happy
19336 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19337 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19338 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19339 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19340 salt
->salt_buf
[4] = salt
->salt_iter
;
19342 return (PARSER_OK
);
19345 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19347 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19349 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19351 uint
*digest
= (uint
*) hash_buf
->digest
;
19353 salt_t
*salt
= hash_buf
->salt
;
19359 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19361 char *hash_pos
= strchr (salt_pos
, '$');
19363 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19365 u32 salt_len
= hash_pos
- salt_pos
;
19367 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19371 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19373 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19377 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19378 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19396 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19397 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19399 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19400 salt
->salt_len
= 8;
19402 return (PARSER_OK
);
19405 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19407 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19409 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19411 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19413 if (c19
& 3) return (PARSER_HASH_VALUE
);
19415 salt_t
*salt
= hash_buf
->salt
;
19417 u32
*digest
= (u32
*) hash_buf
->digest
;
19421 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19422 | itoa64_to_int (input_buf
[2]) << 6
19423 | itoa64_to_int (input_buf
[3]) << 12
19424 | itoa64_to_int (input_buf
[4]) << 18;
19428 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19429 | itoa64_to_int (input_buf
[6]) << 6
19430 | itoa64_to_int (input_buf
[7]) << 12
19431 | itoa64_to_int (input_buf
[8]) << 18;
19433 salt
->salt_len
= 4;
19435 u8 tmp_buf
[100] = { 0 };
19437 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19439 memcpy (digest
, tmp_buf
, 8);
19443 IP (digest
[0], digest
[1], tt
);
19445 digest
[0] = rotr32 (digest
[0], 31);
19446 digest
[1] = rotr32 (digest
[1], 31);
19450 return (PARSER_OK
);
19453 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19455 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19457 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19459 u32
*digest
= (u32
*) hash_buf
->digest
;
19461 salt_t
*salt
= hash_buf
->salt
;
19467 char *type_pos
= input_buf
+ 6 + 1;
19469 char *salt_pos
= strchr (type_pos
, '*');
19471 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19473 u32 type_len
= salt_pos
- type_pos
;
19475 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19479 char *crypted_pos
= strchr (salt_pos
, '*');
19481 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19483 u32 salt_len
= crypted_pos
- salt_pos
;
19485 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19489 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19491 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19497 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19498 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19500 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19501 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19503 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19504 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19505 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19506 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19508 salt
->salt_len
= 24;
19509 salt
->salt_iter
= ROUNDS_RAR3
;
19511 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19512 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19514 digest
[0] = 0xc43d7b00;
19515 digest
[1] = 0x40070000;
19519 return (PARSER_OK
);
19522 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19524 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19526 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19528 u32
*digest
= (u32
*) hash_buf
->digest
;
19530 salt_t
*salt
= hash_buf
->salt
;
19532 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19538 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19540 char *param1_pos
= strchr (param0_pos
, '$');
19542 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19544 u32 param0_len
= param1_pos
- param0_pos
;
19548 char *param2_pos
= strchr (param1_pos
, '$');
19550 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19552 u32 param1_len
= param2_pos
- param1_pos
;
19556 char *param3_pos
= strchr (param2_pos
, '$');
19558 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19560 u32 param2_len
= param3_pos
- param2_pos
;
19564 char *param4_pos
= strchr (param3_pos
, '$');
19566 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19568 u32 param3_len
= param4_pos
- param3_pos
;
19572 char *param5_pos
= strchr (param4_pos
, '$');
19574 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19576 u32 param4_len
= param5_pos
- param4_pos
;
19580 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19582 char *salt_buf
= param1_pos
;
19583 char *iv
= param3_pos
;
19584 char *pswcheck
= param5_pos
;
19586 const uint salt_len
= atoi (param0_pos
);
19587 const uint iterations
= atoi (param2_pos
);
19588 const uint pswcheck_len
= atoi (param4_pos
);
19594 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19595 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19596 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19598 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19599 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19600 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19606 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19607 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19608 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19609 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19611 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19612 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19613 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19614 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19616 salt
->salt_len
= 16;
19618 salt
->salt_sign
[0] = iterations
;
19620 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19626 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19627 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19631 return (PARSER_OK
);
19634 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19636 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19638 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19640 u32
*digest
= (u32
*) hash_buf
->digest
;
19642 salt_t
*salt
= hash_buf
->salt
;
19644 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19651 char *account_pos
= input_buf
+ 11 + 1;
19657 if (account_pos
[0] == '*')
19661 data_pos
= strchr (account_pos
, '*');
19666 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19668 uint account_len
= data_pos
- account_pos
+ 1;
19670 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19675 data_len
= input_len
- 11 - 1 - account_len
- 2;
19677 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19681 /* assume $krb5tgs$23$checksum$edata2 */
19682 data_pos
= account_pos
;
19684 memcpy (krb5tgs
->account_info
, "**", 3);
19686 data_len
= input_len
- 11 - 1 - 1;
19689 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19691 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19693 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19695 const char p0
= data_pos
[i
+ 0];
19696 const char p1
= data_pos
[i
+ 1];
19698 *checksum_ptr
++ = hex_convert (p1
) << 0
19699 | hex_convert (p0
) << 4;
19702 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19704 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19707 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19709 const char p0
= data_pos
[i
+ 0];
19710 const char p1
= data_pos
[i
+ 1];
19711 *edata_ptr
++ = hex_convert (p1
) << 0
19712 | hex_convert (p0
) << 4;
19715 /* this is needed for hmac_md5 */
19716 *edata_ptr
++ = 0x80;
19718 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19719 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19720 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19721 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19723 salt
->salt_len
= 32;
19725 digest
[0] = krb5tgs
->checksum
[0];
19726 digest
[1] = krb5tgs
->checksum
[1];
19727 digest
[2] = krb5tgs
->checksum
[2];
19728 digest
[3] = krb5tgs
->checksum
[3];
19730 return (PARSER_OK
);
19733 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19735 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19737 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19739 u32
*digest
= (u32
*) hash_buf
->digest
;
19741 salt_t
*salt
= hash_buf
->salt
;
19748 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19752 char *wrapped_key_pos
;
19756 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19758 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19760 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19762 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19767 data_pos
= salt_pos
;
19769 wrapped_key_pos
= strchr (salt_pos
, '*');
19771 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19773 uint salt_len
= wrapped_key_pos
- salt_pos
;
19775 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19780 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19782 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19784 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19785 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19786 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19787 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19791 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19792 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19793 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19794 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19795 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19796 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19798 salt
->salt_len
= 40;
19800 digest
[0] = salt
->salt_buf
[0];
19801 digest
[1] = salt
->salt_buf
[1];
19802 digest
[2] = salt
->salt_buf
[2];
19803 digest
[3] = salt
->salt_buf
[3];
19805 return (PARSER_OK
);
19808 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19810 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19812 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19814 u32
*digest
= (u32
*) hash_buf
->digest
;
19816 salt_t
*salt
= hash_buf
->salt
;
19818 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19828 char *algorithm_pos
;
19830 char *final_random_seed_pos
;
19831 u32 final_random_seed_len
;
19833 char *transf_random_seed_pos
;
19834 u32 transf_random_seed_len
;
19839 /* default is no keyfile provided */
19840 char *keyfile_len_pos
;
19841 u32 keyfile_len
= 0;
19842 u32 is_keyfile_present
= 0;
19843 char *keyfile_inline_pos
;
19846 /* specific to version 1 */
19847 char *contents_len_pos
;
19849 char *contents_pos
;
19851 /* specific to version 2 */
19852 char *expected_bytes_pos
;
19853 u32 expected_bytes_len
;
19855 char *contents_hash_pos
;
19856 u32 contents_hash_len
;
19858 version_pos
= input_buf
+ 8 + 1 + 1;
19860 keepass
->version
= atoi (version_pos
);
19862 rounds_pos
= strchr (version_pos
, '*');
19864 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19868 salt
->salt_iter
= (atoi (rounds_pos
));
19870 algorithm_pos
= strchr (rounds_pos
, '*');
19872 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19876 keepass
->algorithm
= atoi (algorithm_pos
);
19878 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19880 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19882 final_random_seed_pos
++;
19884 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19885 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19886 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19887 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19889 if (keepass
->version
== 2)
19891 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19892 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19893 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19894 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19897 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19899 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19901 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19903 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19904 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19906 transf_random_seed_pos
++;
19908 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19909 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19910 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19911 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19912 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19913 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19914 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19915 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19917 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19919 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19921 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19923 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19927 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19928 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19929 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19930 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19932 if (keepass
->version
== 1)
19934 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19936 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19938 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19940 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19942 contents_hash_pos
++;
19944 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19945 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19946 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19947 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19948 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19949 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19950 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19951 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19953 /* get length of contents following */
19954 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19956 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19958 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19960 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19964 u32 inline_flag
= atoi (inline_flag_pos
);
19966 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19968 contents_len_pos
= strchr (inline_flag_pos
, '*');
19970 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19972 contents_len_pos
++;
19974 contents_len
= atoi (contents_len_pos
);
19976 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19978 contents_pos
= strchr (contents_len_pos
, '*');
19980 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19986 keepass
->contents_len
= contents_len
;
19988 contents_len
= contents_len
/ 4;
19990 keyfile_inline_pos
= strchr (contents_pos
, '*');
19992 u32 real_contents_len
;
19994 if (keyfile_inline_pos
== NULL
)
19995 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19998 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19999 keyfile_inline_pos
++;
20000 is_keyfile_present
= 1;
20003 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20005 for (i
= 0; i
< contents_len
; i
++)
20006 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20008 else if (keepass
->version
== 2)
20010 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20012 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20014 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20016 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20018 expected_bytes_pos
++;
20020 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20021 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20022 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20023 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20024 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20025 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20026 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20027 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20029 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20031 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20033 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20035 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20037 contents_hash_pos
++;
20039 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20040 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20041 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20042 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20043 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20044 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20045 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20046 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20048 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20050 if (keyfile_inline_pos
== NULL
)
20051 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20054 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20055 keyfile_inline_pos
++;
20056 is_keyfile_present
= 1;
20058 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20061 if (is_keyfile_present
!= 0)
20063 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20067 keyfile_len
= atoi (keyfile_len_pos
);
20069 keepass
->keyfile_len
= keyfile_len
;
20071 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20073 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20075 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20079 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20081 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20083 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20084 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20085 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20086 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20087 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20088 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20089 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20090 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20093 digest
[0] = keepass
->enc_iv
[0];
20094 digest
[1] = keepass
->enc_iv
[1];
20095 digest
[2] = keepass
->enc_iv
[2];
20096 digest
[3] = keepass
->enc_iv
[3];
20098 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20099 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20100 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20101 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20102 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20103 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20104 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20105 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20107 return (PARSER_OK
);
20110 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20112 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20114 u32
*digest
= (u32
*) hash_buf
->digest
;
20116 salt_t
*salt
= hash_buf
->salt
;
20118 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20119 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20120 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20121 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20122 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20123 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20124 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20125 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20127 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20129 uint salt_len
= input_len
- 64 - 1;
20131 char *salt_buf
= input_buf
+ 64 + 1;
20133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20139 salt
->salt_len
= salt_len
;
20142 * we can precompute the first sha256 transform
20145 uint w
[16] = { 0 };
20147 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20148 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20149 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20150 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20151 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20152 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20153 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20154 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20155 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20156 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20157 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20158 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20159 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20160 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20161 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20162 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20164 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20166 sha256_64 (w
, pc256
);
20168 salt
->salt_buf_pc
[0] = pc256
[0];
20169 salt
->salt_buf_pc
[1] = pc256
[1];
20170 salt
->salt_buf_pc
[2] = pc256
[2];
20171 salt
->salt_buf_pc
[3] = pc256
[3];
20172 salt
->salt_buf_pc
[4] = pc256
[4];
20173 salt
->salt_buf_pc
[5] = pc256
[5];
20174 salt
->salt_buf_pc
[6] = pc256
[6];
20175 salt
->salt_buf_pc
[7] = pc256
[7];
20177 digest
[0] -= pc256
[0];
20178 digest
[1] -= pc256
[1];
20179 digest
[2] -= pc256
[2];
20180 digest
[3] -= pc256
[3];
20181 digest
[4] -= pc256
[4];
20182 digest
[5] -= pc256
[5];
20183 digest
[6] -= pc256
[6];
20184 digest
[7] -= pc256
[7];
20186 return (PARSER_OK
);
20189 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20191 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20193 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20195 u32
*digest
= (u32
*) hash_buf
->digest
;
20197 salt_t
*salt
= hash_buf
->salt
;
20203 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20205 char *data_buf_pos
= strchr (data_len_pos
, '$');
20207 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20209 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20211 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20212 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20216 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20218 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20220 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20222 u32 data_len
= atoi (data_len_pos
);
20224 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20230 char *salt_pos
= data_buf_pos
;
20232 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20233 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20234 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20235 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20237 // this is actually the CT, which is also the hash later (if matched)
20239 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20240 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20241 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20242 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20244 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20246 salt
->salt_iter
= 10 - 1;
20252 digest
[0] = salt
->salt_buf
[4];
20253 digest
[1] = salt
->salt_buf
[5];
20254 digest
[2] = salt
->salt_buf
[6];
20255 digest
[3] = salt
->salt_buf
[7];
20257 return (PARSER_OK
);
20260 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20262 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20264 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20266 u32
*digest
= (u32
*) hash_buf
->digest
;
20268 salt_t
*salt
= hash_buf
->salt
;
20274 char *salt_pos
= input_buf
+ 11 + 1;
20276 char *iter_pos
= strchr (salt_pos
, ',');
20278 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20280 u32 salt_len
= iter_pos
- salt_pos
;
20282 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20286 char *hash_pos
= strchr (iter_pos
, ',');
20288 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20290 u32 iter_len
= hash_pos
- iter_pos
;
20292 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20296 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20298 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20304 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20305 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20306 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20307 salt
->salt_buf
[3] = 0x00018000;
20309 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20310 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20311 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20312 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20314 salt
->salt_len
= salt_len
/ 2;
20316 salt
->salt_iter
= atoi (iter_pos
) - 1;
20322 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20323 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20324 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20325 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20326 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20327 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20328 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20329 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20331 return (PARSER_OK
);
20334 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20336 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20338 u32
*digest
= (u32
*) hash_buf
->digest
;
20340 salt_t
*salt
= hash_buf
->salt
;
20346 char *hash_pos
= input_buf
+ 64;
20347 char *salt1_pos
= input_buf
+ 128;
20348 char *salt2_pos
= input_buf
;
20354 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20355 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20356 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20357 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20359 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20360 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20361 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20362 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20364 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20365 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20366 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20367 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20369 salt
->salt_len
= 48;
20371 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20377 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20378 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20379 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20380 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20381 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20382 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20383 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20384 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20386 return (PARSER_OK
);
20389 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20391 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20393 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20394 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20396 u32
*digest
= (u32
*) hash_buf
->digest
;
20398 salt_t
*salt
= hash_buf
->salt
;
20400 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20406 char *param0_pos
= input_buf
+ 6 + 1;
20408 char *param1_pos
= strchr (param0_pos
, '*');
20410 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20412 u32 param0_len
= param1_pos
- param0_pos
;
20416 char *param2_pos
= strchr (param1_pos
, '*');
20418 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20420 u32 param1_len
= param2_pos
- param1_pos
;
20424 char *param3_pos
= strchr (param2_pos
, '*');
20426 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20428 u32 param2_len
= param3_pos
- param2_pos
;
20432 char *param4_pos
= strchr (param3_pos
, '*');
20434 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20436 u32 param3_len
= param4_pos
- param3_pos
;
20440 char *param5_pos
= strchr (param4_pos
, '*');
20442 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20444 u32 param4_len
= param5_pos
- param4_pos
;
20448 char *param6_pos
= strchr (param5_pos
, '*');
20450 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20452 u32 param5_len
= param6_pos
- param5_pos
;
20456 char *param7_pos
= strchr (param6_pos
, '*');
20458 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20460 u32 param6_len
= param7_pos
- param6_pos
;
20464 char *param8_pos
= strchr (param7_pos
, '*');
20466 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20468 u32 param7_len
= param8_pos
- param7_pos
;
20472 const uint type
= atoi (param0_pos
);
20473 const uint mode
= atoi (param1_pos
);
20474 const uint magic
= atoi (param2_pos
);
20476 char *salt_buf
= param3_pos
;
20478 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20480 const uint compress_length
= atoi (param5_pos
);
20482 char *data_buf
= param6_pos
;
20483 char *auth
= param7_pos
;
20489 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20491 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20493 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20495 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20497 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20499 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20501 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20503 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20505 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20507 if (type
!= 0) return (PARSER_SALT_VALUE
);
20509 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20511 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20513 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20521 zip2
->magic
= magic
;
20525 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20526 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20527 zip2
->salt_buf
[2] = 0;
20528 zip2
->salt_buf
[3] = 0;
20530 zip2
->salt_len
= 8;
20532 else if (mode
== 2)
20534 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20535 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20536 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20537 zip2
->salt_buf
[3] = 0;
20539 zip2
->salt_len
= 12;
20541 else if (mode
== 3)
20543 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20544 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20545 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20546 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20548 zip2
->salt_len
= 16;
20551 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20552 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20553 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20554 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20556 zip2
->verify_bytes
= verify_bytes
;
20558 zip2
->compress_length
= compress_length
;
20560 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20562 for (uint i
= 0; i
< param6_len
; i
+= 2)
20564 const char p0
= data_buf
[i
+ 0];
20565 const char p1
= data_buf
[i
+ 1];
20567 *data_buf_ptr
++ = hex_convert (p1
) << 0
20568 | hex_convert (p0
) << 4;
20573 *data_buf_ptr
= 0x80;
20575 char *auth_ptr
= (char *) zip2
->auth_buf
;
20577 for (uint i
= 0; i
< param7_len
; i
+= 2)
20579 const char p0
= auth
[i
+ 0];
20580 const char p1
= auth
[i
+ 1];
20582 *auth_ptr
++ = hex_convert (p1
) << 0
20583 | hex_convert (p0
) << 4;
20592 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20593 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20594 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20595 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20596 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20597 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20598 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20599 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20601 salt
->salt_len
= 32;
20603 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20606 * digest buf (fake)
20609 digest
[0] = zip2
->auth_buf
[0];
20610 digest
[1] = zip2
->auth_buf
[1];
20611 digest
[2] = zip2
->auth_buf
[2];
20612 digest
[3] = zip2
->auth_buf
[3];
20614 return (PARSER_OK
);
20617 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20619 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20621 u32
*digest
= (u32
*) hash_buf
->digest
;
20623 salt_t
*salt
= hash_buf
->salt
;
20625 win8phone_t
*esalt
= hash_buf
->esalt
;
20627 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20628 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20629 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20630 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20631 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20632 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20633 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20634 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20636 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20638 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20640 u32
*salt_buf
= esalt
->salt_buf
;
20642 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20644 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20647 salt
->salt_buf
[0] = salt_buf
[0];
20648 salt
->salt_buf
[1] = salt_buf
[1];
20649 salt
->salt_buf
[2] = salt_buf
[2];
20650 salt
->salt_buf
[3] = salt_buf
[3];
20651 salt
->salt_buf
[4] = salt_buf
[4];
20652 salt
->salt_buf
[5] = salt_buf
[5];
20653 salt
->salt_buf
[6] = salt_buf
[6];
20654 salt
->salt_buf
[7] = salt_buf
[7];
20656 salt
->salt_len
= 64;
20658 return (PARSER_OK
);
20662 * parallel running threads
20667 BOOL WINAPI
sigHandler_default (DWORD sig
)
20671 case CTRL_CLOSE_EVENT
:
20674 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20675 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20676 * function otherwise it is too late (e.g. after returning from this function)
20681 SetConsoleCtrlHandler (NULL
, TRUE
);
20688 case CTRL_LOGOFF_EVENT
:
20689 case CTRL_SHUTDOWN_EVENT
:
20693 SetConsoleCtrlHandler (NULL
, TRUE
);
20701 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20705 case CTRL_CLOSE_EVENT
:
20709 SetConsoleCtrlHandler (NULL
, TRUE
);
20716 case CTRL_LOGOFF_EVENT
:
20717 case CTRL_SHUTDOWN_EVENT
:
20721 SetConsoleCtrlHandler (NULL
, TRUE
);
20729 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20731 if (callback
== NULL
)
20733 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20737 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20743 void sigHandler_default (int sig
)
20747 signal (sig
, NULL
);
20750 void sigHandler_benchmark (int sig
)
20754 signal (sig
, NULL
);
20757 void hc_signal (void (callback
) (int))
20759 if (callback
== NULL
) callback
= SIG_DFL
;
20761 signal (SIGINT
, callback
);
20762 signal (SIGTERM
, callback
);
20763 signal (SIGABRT
, callback
);
20768 void status_display ();
20770 void *thread_keypress (void *p
)
20772 uint quiet
= data
.quiet
;
20776 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20778 int ch
= tty_getchar();
20780 if (ch
== -1) break;
20782 if (ch
== 0) continue;
20784 //https://github.com/hashcat/hashcat/issues/302
20789 hc_thread_mutex_lock (mux_display
);
20805 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20806 if (quiet
== 0) fflush (stdout
);
20818 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20819 if (quiet
== 0) fflush (stdout
);
20831 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20832 if (quiet
== 0) fflush (stdout
);
20844 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20845 if (quiet
== 0) fflush (stdout
);
20853 stop_at_checkpoint ();
20857 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20858 if (quiet
== 0) fflush (stdout
);
20871 //https://github.com/hashcat/hashcat/issues/302
20876 hc_thread_mutex_unlock (mux_display
);
20888 bool class_num (const u8 c
)
20890 return ((c
>= '0') && (c
<= '9'));
20893 bool class_lower (const u8 c
)
20895 return ((c
>= 'a') && (c
<= 'z'));
20898 bool class_upper (const u8 c
)
20900 return ((c
>= 'A') && (c
<= 'Z'));
20903 bool class_alpha (const u8 c
)
20905 return (class_lower (c
) || class_upper (c
));
20908 int conv_ctoi (const u8 c
)
20914 else if (class_upper (c
))
20916 return c
- 'A' + 10;
20922 int conv_itoc (const u8 c
)
20930 return c
+ 'A' - 10;
20940 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20941 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20942 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20943 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20944 #define MAX_KERNEL_RULES 255
20945 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20946 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20947 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20949 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20950 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20951 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20952 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20954 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20959 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20961 switch (rule_buf
[rule_pos
])
20967 case RULE_OP_MANGLE_NOOP
:
20968 SET_NAME (rule
, rule_buf
[rule_pos
]);
20971 case RULE_OP_MANGLE_LREST
:
20972 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 case RULE_OP_MANGLE_UREST
:
20976 SET_NAME (rule
, rule_buf
[rule_pos
]);
20979 case RULE_OP_MANGLE_LREST_UFIRST
:
20980 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 case RULE_OP_MANGLE_UREST_LFIRST
:
20984 SET_NAME (rule
, rule_buf
[rule_pos
]);
20987 case RULE_OP_MANGLE_TREST
:
20988 SET_NAME (rule
, rule_buf
[rule_pos
]);
20991 case RULE_OP_MANGLE_TOGGLE_AT
:
20992 SET_NAME (rule
, rule_buf
[rule_pos
]);
20993 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20996 case RULE_OP_MANGLE_REVERSE
:
20997 SET_NAME (rule
, rule_buf
[rule_pos
]);
21000 case RULE_OP_MANGLE_DUPEWORD
:
21001 SET_NAME (rule
, rule_buf
[rule_pos
]);
21004 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21005 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21009 case RULE_OP_MANGLE_REFLECT
:
21010 SET_NAME (rule
, rule_buf
[rule_pos
]);
21013 case RULE_OP_MANGLE_ROTATE_LEFT
:
21014 SET_NAME (rule
, rule_buf
[rule_pos
]);
21017 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21018 SET_NAME (rule
, rule_buf
[rule_pos
]);
21021 case RULE_OP_MANGLE_APPEND
:
21022 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 SET_P0 (rule
, rule_buf
[rule_pos
]);
21026 case RULE_OP_MANGLE_PREPEND
:
21027 SET_NAME (rule
, rule_buf
[rule_pos
]);
21028 SET_P0 (rule
, rule_buf
[rule_pos
]);
21031 case RULE_OP_MANGLE_DELETE_FIRST
:
21032 SET_NAME (rule
, rule_buf
[rule_pos
]);
21035 case RULE_OP_MANGLE_DELETE_LAST
:
21036 SET_NAME (rule
, rule_buf
[rule_pos
]);
21039 case RULE_OP_MANGLE_DELETE_AT
:
21040 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21044 case RULE_OP_MANGLE_EXTRACT
:
21045 SET_NAME (rule
, rule_buf
[rule_pos
]);
21046 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21047 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_OMIT
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21052 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21053 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21056 case RULE_OP_MANGLE_INSERT
:
21057 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21059 SET_P1 (rule
, rule_buf
[rule_pos
]);
21062 case RULE_OP_MANGLE_OVERSTRIKE
:
21063 SET_NAME (rule
, rule_buf
[rule_pos
]);
21064 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21065 SET_P1 (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_TRUNCATE_AT
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21070 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21073 case RULE_OP_MANGLE_REPLACE
:
21074 SET_NAME (rule
, rule_buf
[rule_pos
]);
21075 SET_P0 (rule
, rule_buf
[rule_pos
]);
21076 SET_P1 (rule
, rule_buf
[rule_pos
]);
21079 case RULE_OP_MANGLE_PURGECHAR
:
21083 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21087 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21088 SET_NAME (rule
, rule_buf
[rule_pos
]);
21089 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21092 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21093 SET_NAME (rule
, rule_buf
[rule_pos
]);
21094 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21097 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21098 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_SWITCH_FIRST
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21105 case RULE_OP_MANGLE_SWITCH_LAST
:
21106 SET_NAME (rule
, rule_buf
[rule_pos
]);
21109 case RULE_OP_MANGLE_SWITCH_AT
:
21110 SET_NAME (rule
, rule_buf
[rule_pos
]);
21111 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21112 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21115 case RULE_OP_MANGLE_CHR_SHIFTL
:
21116 SET_NAME (rule
, rule_buf
[rule_pos
]);
21117 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21120 case RULE_OP_MANGLE_CHR_SHIFTR
:
21121 SET_NAME (rule
, rule_buf
[rule_pos
]);
21122 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21125 case RULE_OP_MANGLE_CHR_INCR
:
21126 SET_NAME (rule
, rule_buf
[rule_pos
]);
21127 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21130 case RULE_OP_MANGLE_CHR_DECR
:
21131 SET_NAME (rule
, rule_buf
[rule_pos
]);
21132 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21135 case RULE_OP_MANGLE_REPLACE_NP1
:
21136 SET_NAME (rule
, rule_buf
[rule_pos
]);
21137 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21140 case RULE_OP_MANGLE_REPLACE_NM1
:
21141 SET_NAME (rule
, rule_buf
[rule_pos
]);
21142 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21145 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21146 SET_NAME (rule
, rule_buf
[rule_pos
]);
21147 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21150 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21151 SET_NAME (rule
, rule_buf
[rule_pos
]);
21152 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21155 case RULE_OP_MANGLE_TITLE
:
21156 SET_NAME (rule
, rule_buf
[rule_pos
]);
21165 if (rule_pos
< rule_len
) return (-1);
21170 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21174 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21178 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21182 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21186 case RULE_OP_MANGLE_NOOP
:
21187 rule_buf
[rule_pos
] = rule_cmd
;
21190 case RULE_OP_MANGLE_LREST
:
21191 rule_buf
[rule_pos
] = rule_cmd
;
21194 case RULE_OP_MANGLE_UREST
:
21195 rule_buf
[rule_pos
] = rule_cmd
;
21198 case RULE_OP_MANGLE_LREST_UFIRST
:
21199 rule_buf
[rule_pos
] = rule_cmd
;
21202 case RULE_OP_MANGLE_UREST_LFIRST
:
21203 rule_buf
[rule_pos
] = rule_cmd
;
21206 case RULE_OP_MANGLE_TREST
:
21207 rule_buf
[rule_pos
] = rule_cmd
;
21210 case RULE_OP_MANGLE_TOGGLE_AT
:
21211 rule_buf
[rule_pos
] = rule_cmd
;
21212 GET_P0_CONV (rule
);
21215 case RULE_OP_MANGLE_REVERSE
:
21216 rule_buf
[rule_pos
] = rule_cmd
;
21219 case RULE_OP_MANGLE_DUPEWORD
:
21220 rule_buf
[rule_pos
] = rule_cmd
;
21223 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21224 rule_buf
[rule_pos
] = rule_cmd
;
21225 GET_P0_CONV (rule
);
21228 case RULE_OP_MANGLE_REFLECT
:
21229 rule_buf
[rule_pos
] = rule_cmd
;
21232 case RULE_OP_MANGLE_ROTATE_LEFT
:
21233 rule_buf
[rule_pos
] = rule_cmd
;
21236 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21237 rule_buf
[rule_pos
] = rule_cmd
;
21240 case RULE_OP_MANGLE_APPEND
:
21241 rule_buf
[rule_pos
] = rule_cmd
;
21245 case RULE_OP_MANGLE_PREPEND
:
21246 rule_buf
[rule_pos
] = rule_cmd
;
21250 case RULE_OP_MANGLE_DELETE_FIRST
:
21251 rule_buf
[rule_pos
] = rule_cmd
;
21254 case RULE_OP_MANGLE_DELETE_LAST
:
21255 rule_buf
[rule_pos
] = rule_cmd
;
21258 case RULE_OP_MANGLE_DELETE_AT
:
21259 rule_buf
[rule_pos
] = rule_cmd
;
21260 GET_P0_CONV (rule
);
21263 case RULE_OP_MANGLE_EXTRACT
:
21264 rule_buf
[rule_pos
] = rule_cmd
;
21265 GET_P0_CONV (rule
);
21266 GET_P1_CONV (rule
);
21269 case RULE_OP_MANGLE_OMIT
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21271 GET_P0_CONV (rule
);
21272 GET_P1_CONV (rule
);
21275 case RULE_OP_MANGLE_INSERT
:
21276 rule_buf
[rule_pos
] = rule_cmd
;
21277 GET_P0_CONV (rule
);
21281 case RULE_OP_MANGLE_OVERSTRIKE
:
21282 rule_buf
[rule_pos
] = rule_cmd
;
21283 GET_P0_CONV (rule
);
21287 case RULE_OP_MANGLE_TRUNCATE_AT
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21289 GET_P0_CONV (rule
);
21292 case RULE_OP_MANGLE_REPLACE
:
21293 rule_buf
[rule_pos
] = rule_cmd
;
21298 case RULE_OP_MANGLE_PURGECHAR
:
21302 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21306 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21307 rule_buf
[rule_pos
] = rule_cmd
;
21308 GET_P0_CONV (rule
);
21311 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21312 rule_buf
[rule_pos
] = rule_cmd
;
21313 GET_P0_CONV (rule
);
21316 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21317 rule_buf
[rule_pos
] = rule_cmd
;
21320 case RULE_OP_MANGLE_SWITCH_FIRST
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21324 case RULE_OP_MANGLE_SWITCH_LAST
:
21325 rule_buf
[rule_pos
] = rule_cmd
;
21328 case RULE_OP_MANGLE_SWITCH_AT
:
21329 rule_buf
[rule_pos
] = rule_cmd
;
21330 GET_P0_CONV (rule
);
21331 GET_P1_CONV (rule
);
21334 case RULE_OP_MANGLE_CHR_SHIFTL
:
21335 rule_buf
[rule_pos
] = rule_cmd
;
21336 GET_P0_CONV (rule
);
21339 case RULE_OP_MANGLE_CHR_SHIFTR
:
21340 rule_buf
[rule_pos
] = rule_cmd
;
21341 GET_P0_CONV (rule
);
21344 case RULE_OP_MANGLE_CHR_INCR
:
21345 rule_buf
[rule_pos
] = rule_cmd
;
21346 GET_P0_CONV (rule
);
21349 case RULE_OP_MANGLE_CHR_DECR
:
21350 rule_buf
[rule_pos
] = rule_cmd
;
21351 GET_P0_CONV (rule
);
21354 case RULE_OP_MANGLE_REPLACE_NP1
:
21355 rule_buf
[rule_pos
] = rule_cmd
;
21356 GET_P0_CONV (rule
);
21359 case RULE_OP_MANGLE_REPLACE_NM1
:
21360 rule_buf
[rule_pos
] = rule_cmd
;
21361 GET_P0_CONV (rule
);
21364 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21365 rule_buf
[rule_pos
] = rule_cmd
;
21366 GET_P0_CONV (rule
);
21369 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21370 rule_buf
[rule_pos
] = rule_cmd
;
21371 GET_P0_CONV (rule
);
21374 case RULE_OP_MANGLE_TITLE
:
21375 rule_buf
[rule_pos
] = rule_cmd
;
21379 return rule_pos
- 1;
21397 * CPU rules : this is from hashcat sources, cpu based rules
21400 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21401 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21403 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21404 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21405 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21407 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21408 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21409 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21411 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21415 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21420 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21424 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21429 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21433 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21438 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21443 for (l
= 0; l
< arr_len
; l
++)
21445 r
= arr_len
- 1 - l
;
21449 MANGLE_SWITCH (arr
, l
, r
);
21455 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21457 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21459 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21461 return (arr_len
* 2);
21464 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21466 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21468 int orig_len
= arr_len
;
21472 for (i
= 0; i
< times
; i
++)
21474 memcpy (&arr
[arr_len
], arr
, orig_len
);
21476 arr_len
+= orig_len
;
21482 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21484 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21486 mangle_double (arr
, arr_len
);
21488 mangle_reverse (arr
+ arr_len
, arr_len
);
21490 return (arr_len
* 2);
21493 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21498 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21500 MANGLE_SWITCH (arr
, l
, r
);
21506 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21511 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21513 MANGLE_SWITCH (arr
, l
, r
);
21519 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21521 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21525 return (arr_len
+ 1);
21528 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21530 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21534 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21536 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21541 return (arr_len
+ 1);
21544 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21546 if (upos
>= arr_len
) return (arr_len
);
21550 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21552 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21555 return (arr_len
- 1);
21558 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21560 if (upos
>= arr_len
) return (arr_len
);
21562 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21566 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21568 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21574 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21576 if (upos
>= arr_len
) return (arr_len
);
21578 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21582 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21584 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21587 return (arr_len
- ulen
);
21590 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21592 if (upos
>= arr_len
) return (arr_len
);
21594 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21598 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21600 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21605 return (arr_len
+ 1);
21608 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
)
21610 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21612 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21614 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21616 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21618 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21620 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21622 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21624 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21626 return (arr_len
+ arr2_cpy
);
21629 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21631 if (upos
>= arr_len
) return (arr_len
);
21638 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21640 if (upos
>= arr_len
) return (arr_len
);
21642 memset (arr
+ upos
, 0, arr_len
- upos
);
21647 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21651 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21653 if (arr
[arr_pos
] != oldc
) continue;
21655 arr
[arr_pos
] = newc
;
21661 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21667 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21669 if (arr
[arr_pos
] == c
) continue;
21671 arr
[ret_len
] = arr
[arr_pos
];
21679 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21681 if (ulen
> arr_len
) return (arr_len
);
21683 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21685 char cs
[100] = { 0 };
21687 memcpy (cs
, arr
, ulen
);
21691 for (i
= 0; i
< ulen
; i
++)
21695 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21701 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21703 if (ulen
> arr_len
) return (arr_len
);
21705 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21707 int upos
= arr_len
- ulen
;
21711 for (i
= 0; i
< ulen
; i
++)
21713 char c
= arr
[upos
+ i
];
21715 arr_len
= mangle_append (arr
, arr_len
, c
);
21721 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21723 if ( arr_len
== 0) return (arr_len
);
21724 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21726 char c
= arr
[upos
];
21730 for (i
= 0; i
< ulen
; i
++)
21732 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21738 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21740 if ( arr_len
== 0) return (arr_len
);
21741 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21745 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21747 int new_pos
= arr_pos
* 2;
21749 arr
[new_pos
] = arr
[arr_pos
];
21751 arr
[new_pos
+ 1] = arr
[arr_pos
];
21754 return (arr_len
* 2);
21757 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21759 if (upos
>= arr_len
) return (arr_len
);
21760 if (upos2
>= arr_len
) return (arr_len
);
21762 MANGLE_SWITCH (arr
, upos
, upos2
);
21767 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21769 MANGLE_SWITCH (arr
, upos
, upos2
);
21774 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21776 if (upos
>= arr_len
) return (arr_len
);
21783 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21785 if (upos
>= arr_len
) return (arr_len
);
21792 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21794 if (upos
>= arr_len
) return (arr_len
);
21801 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21803 if (upos
>= arr_len
) return (arr_len
);
21810 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21812 int upper_next
= 1;
21816 for (pos
= 0; pos
< arr_len
; pos
++)
21818 if (arr
[pos
] == ' ')
21829 MANGLE_UPPER_AT (arr
, pos
);
21833 MANGLE_LOWER_AT (arr
, pos
);
21840 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21842 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21848 for (j
= 0; j
< rp_gen_num
; j
++)
21855 switch ((char) get_random_num (0, 9))
21858 r
= get_random_num (0, sizeof (grp_op_nop
));
21859 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21863 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21864 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21865 p1
= get_random_num (0, sizeof (grp_pos
));
21866 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21870 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21871 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21872 p1
= get_random_num (1, 6);
21873 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21877 r
= get_random_num (0, sizeof (grp_op_chr
));
21878 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21879 p1
= get_random_num (0x20, 0x7e);
21880 rule_buf
[rule_pos
++] = (char) p1
;
21884 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21885 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21886 p1
= get_random_num (0x20, 0x7e);
21887 rule_buf
[rule_pos
++] = (char) p1
;
21888 p2
= get_random_num (0x20, 0x7e);
21890 p2
= get_random_num (0x20, 0x7e);
21891 rule_buf
[rule_pos
++] = (char) p2
;
21895 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21896 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21897 p1
= get_random_num (0, sizeof (grp_pos
));
21898 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21899 p2
= get_random_num (0x20, 0x7e);
21900 rule_buf
[rule_pos
++] = (char) p2
;
21904 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21905 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21906 p1
= get_random_num (0, sizeof (grp_pos
));
21907 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21908 p2
= get_random_num (0, sizeof (grp_pos
));
21910 p2
= get_random_num (0, sizeof (grp_pos
));
21911 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21915 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21916 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21917 p1
= get_random_num (0, sizeof (grp_pos
));
21918 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21919 p2
= get_random_num (1, sizeof (grp_pos
));
21921 p2
= get_random_num (1, sizeof (grp_pos
));
21922 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21926 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21927 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21928 p1
= get_random_num (0, sizeof (grp_pos
));
21929 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21930 p2
= get_random_num (1, sizeof (grp_pos
));
21931 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21932 p3
= get_random_num (0, sizeof (grp_pos
));
21933 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21941 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21943 char mem
[BLOCK_SIZE
] = { 0 };
21945 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21947 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21949 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21951 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21953 int out_len
= in_len
;
21954 int mem_len
= in_len
;
21956 memcpy (out
, in
, out_len
);
21960 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21965 switch (rule
[rule_pos
])
21970 case RULE_OP_MANGLE_NOOP
:
21973 case RULE_OP_MANGLE_LREST
:
21974 out_len
= mangle_lrest (out
, out_len
);
21977 case RULE_OP_MANGLE_UREST
:
21978 out_len
= mangle_urest (out
, out_len
);
21981 case RULE_OP_MANGLE_LREST_UFIRST
:
21982 out_len
= mangle_lrest (out
, out_len
);
21983 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21986 case RULE_OP_MANGLE_UREST_LFIRST
:
21987 out_len
= mangle_urest (out
, out_len
);
21988 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21991 case RULE_OP_MANGLE_TREST
:
21992 out_len
= mangle_trest (out
, out_len
);
21995 case RULE_OP_MANGLE_TOGGLE_AT
:
21996 NEXT_RULEPOS (rule_pos
);
21997 NEXT_RPTOI (rule
, rule_pos
, upos
);
21998 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22001 case RULE_OP_MANGLE_REVERSE
:
22002 out_len
= mangle_reverse (out
, out_len
);
22005 case RULE_OP_MANGLE_DUPEWORD
:
22006 out_len
= mangle_double (out
, out_len
);
22009 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22010 NEXT_RULEPOS (rule_pos
);
22011 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22012 out_len
= mangle_double_times (out
, out_len
, ulen
);
22015 case RULE_OP_MANGLE_REFLECT
:
22016 out_len
= mangle_reflect (out
, out_len
);
22019 case RULE_OP_MANGLE_ROTATE_LEFT
:
22020 mangle_rotate_left (out
, out_len
);
22023 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22024 mangle_rotate_right (out
, out_len
);
22027 case RULE_OP_MANGLE_APPEND
:
22028 NEXT_RULEPOS (rule_pos
);
22029 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22032 case RULE_OP_MANGLE_PREPEND
:
22033 NEXT_RULEPOS (rule_pos
);
22034 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22037 case RULE_OP_MANGLE_DELETE_FIRST
:
22038 out_len
= mangle_delete_at (out
, out_len
, 0);
22041 case RULE_OP_MANGLE_DELETE_LAST
:
22042 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22045 case RULE_OP_MANGLE_DELETE_AT
:
22046 NEXT_RULEPOS (rule_pos
);
22047 NEXT_RPTOI (rule
, rule_pos
, upos
);
22048 out_len
= mangle_delete_at (out
, out_len
, upos
);
22051 case RULE_OP_MANGLE_EXTRACT
:
22052 NEXT_RULEPOS (rule_pos
);
22053 NEXT_RPTOI (rule
, rule_pos
, upos
);
22054 NEXT_RULEPOS (rule_pos
);
22055 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22056 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22059 case RULE_OP_MANGLE_OMIT
:
22060 NEXT_RULEPOS (rule_pos
);
22061 NEXT_RPTOI (rule
, rule_pos
, upos
);
22062 NEXT_RULEPOS (rule_pos
);
22063 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22064 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22067 case RULE_OP_MANGLE_INSERT
:
22068 NEXT_RULEPOS (rule_pos
);
22069 NEXT_RPTOI (rule
, rule_pos
, upos
);
22070 NEXT_RULEPOS (rule_pos
);
22071 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22074 case RULE_OP_MANGLE_OVERSTRIKE
:
22075 NEXT_RULEPOS (rule_pos
);
22076 NEXT_RPTOI (rule
, rule_pos
, upos
);
22077 NEXT_RULEPOS (rule_pos
);
22078 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22081 case RULE_OP_MANGLE_TRUNCATE_AT
:
22082 NEXT_RULEPOS (rule_pos
);
22083 NEXT_RPTOI (rule
, rule_pos
, upos
);
22084 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22087 case RULE_OP_MANGLE_REPLACE
:
22088 NEXT_RULEPOS (rule_pos
);
22089 NEXT_RULEPOS (rule_pos
);
22090 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22093 case RULE_OP_MANGLE_PURGECHAR
:
22094 NEXT_RULEPOS (rule_pos
);
22095 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22098 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22102 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22103 NEXT_RULEPOS (rule_pos
);
22104 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22105 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22108 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22109 NEXT_RULEPOS (rule_pos
);
22110 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22111 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22114 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22115 out_len
= mangle_dupechar (out
, out_len
);
22118 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22119 NEXT_RULEPOS (rule_pos
);
22120 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22121 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22124 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22125 NEXT_RULEPOS (rule_pos
);
22126 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22127 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22130 case RULE_OP_MANGLE_SWITCH_FIRST
:
22131 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22134 case RULE_OP_MANGLE_SWITCH_LAST
:
22135 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22138 case RULE_OP_MANGLE_SWITCH_AT
:
22139 NEXT_RULEPOS (rule_pos
);
22140 NEXT_RPTOI (rule
, rule_pos
, upos
);
22141 NEXT_RULEPOS (rule_pos
);
22142 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22143 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22146 case RULE_OP_MANGLE_CHR_SHIFTL
:
22147 NEXT_RULEPOS (rule_pos
);
22148 NEXT_RPTOI (rule
, rule_pos
, upos
);
22149 mangle_chr_shiftl (out
, out_len
, upos
);
22152 case RULE_OP_MANGLE_CHR_SHIFTR
:
22153 NEXT_RULEPOS (rule_pos
);
22154 NEXT_RPTOI (rule
, rule_pos
, upos
);
22155 mangle_chr_shiftr (out
, out_len
, upos
);
22158 case RULE_OP_MANGLE_CHR_INCR
:
22159 NEXT_RULEPOS (rule_pos
);
22160 NEXT_RPTOI (rule
, rule_pos
, upos
);
22161 mangle_chr_incr (out
, out_len
, upos
);
22164 case RULE_OP_MANGLE_CHR_DECR
:
22165 NEXT_RULEPOS (rule_pos
);
22166 NEXT_RPTOI (rule
, rule_pos
, upos
);
22167 mangle_chr_decr (out
, out_len
, upos
);
22170 case RULE_OP_MANGLE_REPLACE_NP1
:
22171 NEXT_RULEPOS (rule_pos
);
22172 NEXT_RPTOI (rule
, rule_pos
, upos
);
22173 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22176 case RULE_OP_MANGLE_REPLACE_NM1
:
22177 NEXT_RULEPOS (rule_pos
);
22178 NEXT_RPTOI (rule
, rule_pos
, upos
);
22179 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22182 case RULE_OP_MANGLE_TITLE
:
22183 out_len
= mangle_title (out
, out_len
);
22186 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22187 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22188 NEXT_RULEPOS (rule_pos
);
22189 NEXT_RPTOI (rule
, rule_pos
, upos
);
22190 NEXT_RULEPOS (rule_pos
);
22191 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22192 NEXT_RULEPOS (rule_pos
);
22193 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22194 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22197 case RULE_OP_MANGLE_APPEND_MEMORY
:
22198 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22199 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22200 memcpy (out
+ out_len
, mem
, mem_len
);
22201 out_len
+= mem_len
;
22204 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22205 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22206 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22207 memcpy (mem
+ mem_len
, out
, out_len
);
22208 out_len
+= mem_len
;
22209 memcpy (out
, mem
, out_len
);
22212 case RULE_OP_MEMORIZE_WORD
:
22213 memcpy (mem
, out
, out_len
);
22217 case RULE_OP_REJECT_LESS
:
22218 NEXT_RULEPOS (rule_pos
);
22219 NEXT_RPTOI (rule
, rule_pos
, upos
);
22220 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22223 case RULE_OP_REJECT_GREATER
:
22224 NEXT_RULEPOS (rule_pos
);
22225 NEXT_RPTOI (rule
, rule_pos
, upos
);
22226 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22229 case RULE_OP_REJECT_CONTAIN
:
22230 NEXT_RULEPOS (rule_pos
);
22231 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22234 case RULE_OP_REJECT_NOT_CONTAIN
:
22235 NEXT_RULEPOS (rule_pos
);
22236 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22239 case RULE_OP_REJECT_EQUAL_FIRST
:
22240 NEXT_RULEPOS (rule_pos
);
22241 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22244 case RULE_OP_REJECT_EQUAL_LAST
:
22245 NEXT_RULEPOS (rule_pos
);
22246 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22249 case RULE_OP_REJECT_EQUAL_AT
:
22250 NEXT_RULEPOS (rule_pos
);
22251 NEXT_RPTOI (rule
, rule_pos
, upos
);
22252 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22253 NEXT_RULEPOS (rule_pos
);
22254 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22257 case RULE_OP_REJECT_CONTAINS
:
22258 NEXT_RULEPOS (rule_pos
);
22259 NEXT_RPTOI (rule
, rule_pos
, upos
);
22260 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22261 NEXT_RULEPOS (rule_pos
);
22262 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22263 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22266 case RULE_OP_REJECT_MEMORY
:
22267 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22271 return (RULE_RC_SYNTAX_ERROR
);
22276 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);