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 load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9225 FILE *fp
= fopen (kernel_file
, "rb");
9231 memset (&st
, 0, sizeof (st
));
9233 stat (kernel_file
, &st
);
9235 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9237 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9239 if (num_read
!= (size_t) st
.st_size
)
9241 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9248 buf
[st
.st_size
] = 0;
9250 for (int i
= 0; i
< num_devices
; i
++)
9252 kernel_lengths
[i
] = (size_t) st
.st_size
;
9254 kernel_sources
[i
] = buf
;
9259 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9267 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9269 if (binary_size
> 0)
9271 FILE *fp
= fopen (dst
, "wb");
9274 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9285 restore_data_t
*init_restore (int argc
, char **argv
)
9287 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9289 if (data
.restore_disable
== 0)
9291 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9295 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9299 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9308 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9310 int pidbin_len
= -1;
9313 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9315 FILE *fd
= fopen (pidbin
, "rb");
9319 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9321 pidbin
[pidbin_len
] = 0;
9325 char *argv0_r
= strrchr (argv
[0], '/');
9327 char *pidbin_r
= strrchr (pidbin
, '/');
9329 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9331 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9333 if (strcmp (argv0_r
, pidbin_r
) == 0)
9335 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9342 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9344 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9346 int pidbin2_len
= -1;
9348 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9349 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9351 pidbin
[pidbin_len
] = 0;
9352 pidbin2
[pidbin2_len
] = 0;
9356 if (strcmp (pidbin
, pidbin2
) == 0)
9358 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9371 if (rd
->version_bin
< RESTORE_MIN
)
9373 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9380 memset (rd
, 0, sizeof (restore_data_t
));
9382 rd
->version_bin
= VERSION_BIN
;
9385 rd
->pid
= getpid ();
9387 rd
->pid
= GetCurrentProcessId ();
9390 if (getcwd (rd
->cwd
, 255) == NULL
)
9403 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9405 FILE *fp
= fopen (eff_restore_file
, "rb");
9409 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9414 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9416 log_error ("ERROR: Can't read %s", eff_restore_file
);
9421 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9423 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9425 for (uint i
= 0; i
< rd
->argc
; i
++)
9427 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9429 log_error ("ERROR: Can't read %s", eff_restore_file
);
9434 size_t len
= strlen (buf
);
9436 if (len
) buf
[len
- 1] = 0;
9438 rd
->argv
[i
] = mystrdup (buf
);
9445 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9447 if (chdir (rd
->cwd
))
9449 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9450 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9451 " https://github.com/philsmd/analyze_hc_restore\n"
9452 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9458 u64
get_lowest_words_done ()
9462 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9464 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9466 if (device_param
->skipped
) continue;
9468 const u64 words_done
= device_param
->words_done
;
9470 if (words_done
< words_cur
) words_cur
= words_done
;
9473 // It's possible that a device's workload isn't finished right after a restore-case.
9474 // In that case, this function would return 0 and overwrite the real restore point
9475 // There's also data.words_cur which is set to rd->words_cur but it changes while
9476 // the attack is running therefore we should stick to rd->words_cur.
9477 // Note that -s influences rd->words_cur we should keep a close look on that.
9479 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9484 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9486 u64 words_cur
= get_lowest_words_done ();
9488 rd
->words_cur
= words_cur
;
9490 FILE *fp
= fopen (new_restore_file
, "wb");
9494 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9499 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9501 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9506 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9508 for (uint i
= 0; i
< rd
->argc
; i
++)
9510 fprintf (fp
, "%s", rd
->argv
[i
]);
9516 fsync (fileno (fp
));
9521 void cycle_restore ()
9523 const char *eff_restore_file
= data
.eff_restore_file
;
9524 const char *new_restore_file
= data
.new_restore_file
;
9526 restore_data_t
*rd
= data
.rd
;
9528 write_restore (new_restore_file
, rd
);
9532 memset (&st
, 0, sizeof(st
));
9534 if (stat (eff_restore_file
, &st
) == 0)
9536 if (unlink (eff_restore_file
))
9538 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9542 if (rename (new_restore_file
, eff_restore_file
))
9544 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9548 void check_checkpoint ()
9550 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9552 u64 words_cur
= get_lowest_words_done ();
9554 if (words_cur
!= data
.checkpoint_cur_words
)
9564 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9568 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9570 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9572 myfree (alias
->device_name
);
9573 myfree (alias
->alias_name
);
9576 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9578 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9580 myfree (entry
->device_name
);
9583 myfree (tuning_db
->alias_buf
);
9584 myfree (tuning_db
->entry_buf
);
9589 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9591 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9593 int num_lines
= count_lines (fp
);
9595 // a bit over-allocated
9597 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9598 tuning_db
->alias_cnt
= 0;
9600 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9601 tuning_db
->entry_cnt
= 0;
9606 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9608 FILE *fp
= fopen (tuning_db_file
, "rb");
9612 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9617 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9623 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9627 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9629 if (line_buf
== NULL
) break;
9633 const int line_len
= in_superchop (line_buf
);
9635 if (line_len
== 0) continue;
9637 if (line_buf
[0] == '#') continue;
9641 char *token_ptr
[7] = { NULL
};
9645 char *next
= strtok (line_buf
, "\t ");
9647 token_ptr
[token_cnt
] = next
;
9651 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9653 token_ptr
[token_cnt
] = next
;
9660 char *device_name
= token_ptr
[0];
9661 char *alias_name
= token_ptr
[1];
9663 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9665 alias
->device_name
= mystrdup (device_name
);
9666 alias
->alias_name
= mystrdup (alias_name
);
9668 tuning_db
->alias_cnt
++;
9670 else if (token_cnt
== 6)
9672 if ((token_ptr
[1][0] != '0') &&
9673 (token_ptr
[1][0] != '1') &&
9674 (token_ptr
[1][0] != '3') &&
9675 (token_ptr
[1][0] != '*'))
9677 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9682 if ((token_ptr
[3][0] != '1') &&
9683 (token_ptr
[3][0] != '2') &&
9684 (token_ptr
[3][0] != '4') &&
9685 (token_ptr
[3][0] != '8') &&
9686 (token_ptr
[3][0] != 'N'))
9688 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9693 char *device_name
= token_ptr
[0];
9695 int attack_mode
= -1;
9697 int vector_width
= -1;
9698 int kernel_accel
= -1;
9699 int kernel_loops
= -1;
9701 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9702 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9703 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9705 if (token_ptr
[4][0] != 'A')
9707 kernel_accel
= atoi (token_ptr
[4]);
9709 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9711 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9721 if (token_ptr
[5][0] != 'A')
9723 kernel_loops
= atoi (token_ptr
[5]);
9725 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9727 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9737 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9739 entry
->device_name
= mystrdup (device_name
);
9740 entry
->attack_mode
= attack_mode
;
9741 entry
->hash_type
= hash_type
;
9742 entry
->vector_width
= vector_width
;
9743 entry
->kernel_accel
= kernel_accel
;
9744 entry
->kernel_loops
= kernel_loops
;
9746 tuning_db
->entry_cnt
++;
9750 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9760 // todo: print loaded 'cnt' message
9762 // sort the database
9764 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9765 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9770 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9772 static tuning_db_entry_t s
;
9774 // first we need to convert all spaces in the device_name to underscore
9776 char *device_name_nospace
= strdup (device_param
->device_name
);
9778 int device_name_length
= strlen (device_name_nospace
);
9782 for (i
= 0; i
< device_name_length
; i
++)
9784 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9787 // find out if there's an alias configured
9789 tuning_db_alias_t a
;
9791 a
.device_name
= device_name_nospace
;
9793 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
);
9795 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9797 // attack-mode 6 and 7 are attack-mode 1 basically
9799 if (attack_mode
== 6) attack_mode
= 1;
9800 if (attack_mode
== 7) attack_mode
= 1;
9802 // bsearch is not ideal but fast enough
9804 s
.device_name
= device_name_nospace
;
9805 s
.attack_mode
= attack_mode
;
9806 s
.hash_type
= hash_type
;
9808 tuning_db_entry_t
*entry
= NULL
;
9810 // this will produce all 2^3 combinations required
9812 for (i
= 0; i
< 8; i
++)
9814 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9815 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9816 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9818 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9820 if (entry
!= NULL
) break;
9822 // in non-wildcard mode do some additional checks:
9826 // in case we have an alias-name
9828 if (alias_name
!= NULL
)
9830 s
.device_name
= alias_name
;
9832 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9834 if (entry
!= NULL
) break;
9837 // or by device type
9839 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9841 s
.device_name
= "DEVICE_TYPE_CPU";
9843 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9845 s
.device_name
= "DEVICE_TYPE_GPU";
9847 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9849 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9852 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9854 if (entry
!= NULL
) break;
9858 // free converted device_name
9860 myfree (device_name_nospace
);
9869 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9871 u8 tmp
[256] = { 0 };
9873 if (salt_len
> sizeof (tmp
))
9878 memcpy (tmp
, in
, salt_len
);
9880 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9882 if ((salt_len
% 2) == 0)
9884 u32 new_salt_len
= salt_len
/ 2;
9886 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9891 tmp
[i
] = hex_convert (p1
) << 0;
9892 tmp
[i
] |= hex_convert (p0
) << 4;
9895 salt_len
= new_salt_len
;
9902 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9904 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9907 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9909 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9913 u32
*tmp_uint
= (u32
*) tmp
;
9915 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9916 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9917 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9918 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9919 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9920 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9921 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9922 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9923 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9924 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9926 salt_len
= salt_len
* 2;
9934 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9936 lowercase (tmp
, salt_len
);
9939 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9941 uppercase (tmp
, salt_len
);
9946 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9951 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9956 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9958 u32
*tmp_uint
= (uint
*) tmp
;
9964 for (u32 i
= 0; i
< max
; i
++)
9966 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9969 // Important: we may need to increase the length of memcpy since
9970 // we don't want to "loose" some swapped bytes (could happen if
9971 // they do not perfectly fit in the 4-byte blocks)
9972 // Memcpy does always copy the bytes in the BE order, but since
9973 // we swapped them, some important bytes could be in positions
9974 // we normally skip with the original len
9976 if (len
% 4) len
+= 4 - (len
% 4);
9979 memcpy (out
, tmp
, len
);
9984 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9986 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9988 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9990 u32
*digest
= (u32
*) hash_buf
->digest
;
9992 salt_t
*salt
= hash_buf
->salt
;
9994 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9996 char *iter_pos
= input_buf
+ 4;
9998 salt
->salt_iter
= 1 << atoi (iter_pos
);
10000 char *salt_pos
= strchr (iter_pos
, '$');
10002 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10006 uint salt_len
= 16;
10008 salt
->salt_len
= salt_len
;
10010 u8 tmp_buf
[100] = { 0 };
10012 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10014 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10016 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10018 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10019 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10020 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10021 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10023 char *hash_pos
= salt_pos
+ 22;
10025 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10027 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10029 memcpy (digest
, tmp_buf
, 24);
10031 digest
[0] = byte_swap_32 (digest
[0]);
10032 digest
[1] = byte_swap_32 (digest
[1]);
10033 digest
[2] = byte_swap_32 (digest
[2]);
10034 digest
[3] = byte_swap_32 (digest
[3]);
10035 digest
[4] = byte_swap_32 (digest
[4]);
10036 digest
[5] = byte_swap_32 (digest
[5]);
10038 digest
[5] &= ~0xff; // its just 23 not 24 !
10040 return (PARSER_OK
);
10043 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10045 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10047 u32
*digest
= (u32
*) hash_buf
->digest
;
10049 u8 tmp_buf
[100] = { 0 };
10051 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10053 memcpy (digest
, tmp_buf
, 32);
10055 digest
[0] = byte_swap_32 (digest
[0]);
10056 digest
[1] = byte_swap_32 (digest
[1]);
10057 digest
[2] = byte_swap_32 (digest
[2]);
10058 digest
[3] = byte_swap_32 (digest
[3]);
10059 digest
[4] = byte_swap_32 (digest
[4]);
10060 digest
[5] = byte_swap_32 (digest
[5]);
10061 digest
[6] = byte_swap_32 (digest
[6]);
10062 digest
[7] = byte_swap_32 (digest
[7]);
10064 digest
[0] -= SHA256M_A
;
10065 digest
[1] -= SHA256M_B
;
10066 digest
[2] -= SHA256M_C
;
10067 digest
[3] -= SHA256M_D
;
10068 digest
[4] -= SHA256M_E
;
10069 digest
[5] -= SHA256M_F
;
10070 digest
[6] -= SHA256M_G
;
10071 digest
[7] -= SHA256M_H
;
10073 return (PARSER_OK
);
10076 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10078 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10080 u32
*digest
= (u32
*) hash_buf
->digest
;
10082 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10083 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10085 digest
[0] = byte_swap_32 (digest
[0]);
10086 digest
[1] = byte_swap_32 (digest
[1]);
10090 IP (digest
[0], digest
[1], tt
);
10092 digest
[0] = digest
[0];
10093 digest
[1] = digest
[1];
10097 return (PARSER_OK
);
10100 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10102 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10104 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10106 u32
*digest
= (u32
*) hash_buf
->digest
;
10108 salt_t
*salt
= hash_buf
->salt
;
10110 char *hash_pos
= input_buf
+ 10;
10112 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10113 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10114 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10115 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10116 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10118 digest
[0] -= SHA1M_A
;
10119 digest
[1] -= SHA1M_B
;
10120 digest
[2] -= SHA1M_C
;
10121 digest
[3] -= SHA1M_D
;
10122 digest
[4] -= SHA1M_E
;
10124 uint salt_len
= 10;
10126 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10128 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10132 salt
->salt_len
= salt_len
;
10134 return (PARSER_OK
);
10137 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10139 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10141 u32
*digest
= (u32
*) hash_buf
->digest
;
10143 salt_t
*salt
= hash_buf
->salt
;
10145 char *hash_pos
= input_buf
+ 8;
10147 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10148 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10149 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10150 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10151 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10153 digest
[0] -= SHA1M_A
;
10154 digest
[1] -= SHA1M_B
;
10155 digest
[2] -= SHA1M_C
;
10156 digest
[3] -= SHA1M_D
;
10157 digest
[4] -= SHA1M_E
;
10161 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10163 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10165 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10167 salt
->salt_len
= salt_len
;
10169 return (PARSER_OK
);
10172 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10174 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10176 u64
*digest
= (u64
*) hash_buf
->digest
;
10178 salt_t
*salt
= hash_buf
->salt
;
10180 char *hash_pos
= input_buf
+ 8;
10182 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10183 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10184 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10185 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10186 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10187 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10188 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10189 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10191 digest
[0] -= SHA512M_A
;
10192 digest
[1] -= SHA512M_B
;
10193 digest
[2] -= SHA512M_C
;
10194 digest
[3] -= SHA512M_D
;
10195 digest
[4] -= SHA512M_E
;
10196 digest
[5] -= SHA512M_F
;
10197 digest
[6] -= SHA512M_G
;
10198 digest
[7] -= SHA512M_H
;
10202 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10204 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10206 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10208 salt
->salt_len
= salt_len
;
10210 return (PARSER_OK
);
10213 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10215 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10217 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10221 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10224 u32
*digest
= (u32
*) hash_buf
->digest
;
10226 salt_t
*salt
= hash_buf
->salt
;
10228 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10229 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10230 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10231 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10233 digest
[0] = byte_swap_32 (digest
[0]);
10234 digest
[1] = byte_swap_32 (digest
[1]);
10235 digest
[2] = byte_swap_32 (digest
[2]);
10236 digest
[3] = byte_swap_32 (digest
[3]);
10238 digest
[0] -= MD5M_A
;
10239 digest
[1] -= MD5M_B
;
10240 digest
[2] -= MD5M_C
;
10241 digest
[3] -= MD5M_D
;
10243 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10245 uint salt_len
= input_len
- 32 - 1;
10247 char *salt_buf
= input_buf
+ 32 + 1;
10249 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10251 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10253 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10255 salt
->salt_len
= salt_len
;
10257 return (PARSER_OK
);
10260 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10262 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10264 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10268 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10273 char clean_input_buf
[32] = { 0 };
10275 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10276 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10278 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10282 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10288 clean_input_buf
[k
] = input_buf
[i
];
10296 u32
*digest
= (u32
*) hash_buf
->digest
;
10298 salt_t
*salt
= hash_buf
->salt
;
10300 u32 a
, b
, c
, d
, e
, f
;
10302 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10303 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10304 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10305 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10306 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10307 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10309 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10310 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10312 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10313 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10314 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10315 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10316 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10317 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10319 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10320 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10322 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10323 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10324 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10325 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10326 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10327 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10329 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10330 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10332 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10333 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10334 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10335 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10336 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10337 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10339 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10340 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10342 digest
[0] = byte_swap_32 (digest
[0]);
10343 digest
[1] = byte_swap_32 (digest
[1]);
10344 digest
[2] = byte_swap_32 (digest
[2]);
10345 digest
[3] = byte_swap_32 (digest
[3]);
10347 digest
[0] -= MD5M_A
;
10348 digest
[1] -= MD5M_B
;
10349 digest
[2] -= MD5M_C
;
10350 digest
[3] -= MD5M_D
;
10352 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10354 uint salt_len
= input_len
- 30 - 1;
10356 char *salt_buf
= input_buf
+ 30 + 1;
10358 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10360 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10362 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10363 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10365 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10367 salt
->salt_len
= salt_len
;
10369 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10371 salt
->salt_len
+= 22;
10373 return (PARSER_OK
);
10376 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10378 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10380 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10384 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10387 u32
*digest
= (u32
*) hash_buf
->digest
;
10389 salt_t
*salt
= hash_buf
->salt
;
10391 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10392 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10393 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10394 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10395 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10397 digest
[0] -= SHA1M_A
;
10398 digest
[1] -= SHA1M_B
;
10399 digest
[2] -= SHA1M_C
;
10400 digest
[3] -= SHA1M_D
;
10401 digest
[4] -= SHA1M_E
;
10403 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10405 uint salt_len
= input_len
- 40 - 1;
10407 char *salt_buf
= input_buf
+ 40 + 1;
10409 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10411 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10413 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10415 salt
->salt_len
= salt_len
;
10417 return (PARSER_OK
);
10420 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10422 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10424 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10428 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10431 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10433 char *iter_pos
= input_buf
+ 6;
10435 salt_t
*salt
= hash_buf
->salt
;
10437 uint iter
= atoi (iter_pos
);
10441 iter
= ROUNDS_DCC2
;
10444 salt
->salt_iter
= iter
- 1;
10446 char *salt_pos
= strchr (iter_pos
, '#');
10448 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10452 char *digest_pos
= strchr (salt_pos
, '#');
10454 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10458 uint salt_len
= digest_pos
- salt_pos
- 1;
10460 u32
*digest
= (u32
*) hash_buf
->digest
;
10462 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10463 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10464 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10465 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10467 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10469 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10471 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10473 salt
->salt_len
= salt_len
;
10475 return (PARSER_OK
);
10478 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10480 u32
*digest
= (u32
*) hash_buf
->digest
;
10482 salt_t
*salt
= hash_buf
->salt
;
10484 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10488 memcpy (&in
, input_buf
, input_len
);
10490 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10492 memcpy (digest
, in
.keymic
, 16);
10495 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10496 The phrase "Pairwise key expansion"
10497 Access Point Address (referred to as Authenticator Address AA)
10498 Supplicant Address (referred to as Supplicant Address SA)
10499 Access Point Nonce (referred to as Authenticator Anonce)
10500 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10503 uint salt_len
= strlen (in
.essid
);
10507 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10509 return (PARSER_SALT_LENGTH
);
10512 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10514 salt
->salt_len
= salt_len
;
10516 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10518 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10520 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10522 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10524 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10525 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10529 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10530 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10533 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10535 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10536 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10540 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10541 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10544 for (int i
= 0; i
< 25; i
++)
10546 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10549 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10550 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10551 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10552 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10554 wpa
->keyver
= in
.keyver
;
10556 if (wpa
->keyver
> 255)
10558 log_info ("ATTENTION!");
10559 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10560 log_info (" This could be due to a recent aircrack-ng bug.");
10561 log_info (" The key version was automatically reset to a reasonable value.");
10564 wpa
->keyver
&= 0xff;
10567 wpa
->eapol_size
= in
.eapol_size
;
10569 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10571 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10573 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10575 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10577 if (wpa
->keyver
== 1)
10583 digest
[0] = byte_swap_32 (digest
[0]);
10584 digest
[1] = byte_swap_32 (digest
[1]);
10585 digest
[2] = byte_swap_32 (digest
[2]);
10586 digest
[3] = byte_swap_32 (digest
[3]);
10588 for (int i
= 0; i
< 64; i
++)
10590 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10594 uint32_t *p0
= (uint32_t *) in
.essid
;
10598 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10599 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10601 salt
->salt_buf
[10] = c0
;
10602 salt
->salt_buf
[11] = c1
;
10604 return (PARSER_OK
);
10607 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10609 u32
*digest
= (u32
*) hash_buf
->digest
;
10611 salt_t
*salt
= hash_buf
->salt
;
10613 if (input_len
== 0)
10615 log_error ("Password Safe v2 container not specified");
10620 FILE *fp
= fopen (input_buf
, "rb");
10624 log_error ("%s: %s", input_buf
, strerror (errno
));
10631 memset (&buf
, 0, sizeof (psafe2_hdr
));
10633 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10637 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10639 salt
->salt_buf
[0] = buf
.random
[0];
10640 salt
->salt_buf
[1] = buf
.random
[1];
10642 salt
->salt_len
= 8;
10643 salt
->salt_iter
= 1000;
10645 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10646 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10647 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10648 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10649 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10651 return (PARSER_OK
);
10654 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10656 u32
*digest
= (u32
*) hash_buf
->digest
;
10658 salt_t
*salt
= hash_buf
->salt
;
10660 if (input_len
== 0)
10662 log_error (".psafe3 not specified");
10667 FILE *fp
= fopen (input_buf
, "rb");
10671 log_error ("%s: %s", input_buf
, strerror (errno
));
10678 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10682 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10684 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10686 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10688 salt
->salt_iter
= in
.iterations
+ 1;
10690 salt
->salt_buf
[0] = in
.salt_buf
[0];
10691 salt
->salt_buf
[1] = in
.salt_buf
[1];
10692 salt
->salt_buf
[2] = in
.salt_buf
[2];
10693 salt
->salt_buf
[3] = in
.salt_buf
[3];
10694 salt
->salt_buf
[4] = in
.salt_buf
[4];
10695 salt
->salt_buf
[5] = in
.salt_buf
[5];
10696 salt
->salt_buf
[6] = in
.salt_buf
[6];
10697 salt
->salt_buf
[7] = in
.salt_buf
[7];
10699 salt
->salt_len
= 32;
10701 digest
[0] = in
.hash_buf
[0];
10702 digest
[1] = in
.hash_buf
[1];
10703 digest
[2] = in
.hash_buf
[2];
10704 digest
[3] = in
.hash_buf
[3];
10705 digest
[4] = in
.hash_buf
[4];
10706 digest
[5] = in
.hash_buf
[5];
10707 digest
[6] = in
.hash_buf
[6];
10708 digest
[7] = in
.hash_buf
[7];
10710 digest
[0] = byte_swap_32 (digest
[0]);
10711 digest
[1] = byte_swap_32 (digest
[1]);
10712 digest
[2] = byte_swap_32 (digest
[2]);
10713 digest
[3] = byte_swap_32 (digest
[3]);
10714 digest
[4] = byte_swap_32 (digest
[4]);
10715 digest
[5] = byte_swap_32 (digest
[5]);
10716 digest
[6] = byte_swap_32 (digest
[6]);
10717 digest
[7] = byte_swap_32 (digest
[7]);
10719 return (PARSER_OK
);
10722 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10724 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10726 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10728 u32
*digest
= (u32
*) hash_buf
->digest
;
10730 salt_t
*salt
= hash_buf
->salt
;
10732 char *iter_pos
= input_buf
+ 3;
10734 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10736 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10738 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10740 salt
->salt_iter
= salt_iter
;
10742 char *salt_pos
= iter_pos
+ 1;
10746 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10748 salt
->salt_len
= salt_len
;
10750 char *hash_pos
= salt_pos
+ salt_len
;
10752 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10754 return (PARSER_OK
);
10757 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10759 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10761 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10763 u32
*digest
= (u32
*) hash_buf
->digest
;
10765 salt_t
*salt
= hash_buf
->salt
;
10767 char *salt_pos
= input_buf
+ 3;
10769 uint iterations_len
= 0;
10771 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10775 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10777 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10778 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10782 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10786 iterations_len
+= 8;
10790 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10793 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10795 char *hash_pos
= strchr (salt_pos
, '$');
10797 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10799 uint salt_len
= hash_pos
- salt_pos
;
10801 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10803 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10805 salt
->salt_len
= salt_len
;
10809 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10811 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10813 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10815 return (PARSER_OK
);
10818 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10820 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10822 u32
*digest
= (u32
*) hash_buf
->digest
;
10824 salt_t
*salt
= hash_buf
->salt
;
10826 char *salt_pos
= input_buf
+ 6;
10828 uint iterations_len
= 0;
10830 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10834 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10836 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10837 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10841 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10845 iterations_len
+= 8;
10849 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10852 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10854 char *hash_pos
= strchr (salt_pos
, '$');
10856 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10858 uint salt_len
= hash_pos
- salt_pos
;
10860 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10862 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10864 salt
->salt_len
= salt_len
;
10868 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10870 return (PARSER_OK
);
10873 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10875 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10877 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10879 u32
*digest
= (u32
*) hash_buf
->digest
;
10881 salt_t
*salt
= hash_buf
->salt
;
10883 char *salt_pos
= input_buf
+ 14;
10885 char *hash_pos
= strchr (salt_pos
, '*');
10887 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10891 uint salt_len
= hash_pos
- salt_pos
- 1;
10893 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10895 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10897 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10899 salt
->salt_len
= salt_len
;
10901 u8 tmp_buf
[100] = { 0 };
10903 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10905 memcpy (digest
, tmp_buf
, 20);
10907 digest
[0] = byte_swap_32 (digest
[0]);
10908 digest
[1] = byte_swap_32 (digest
[1]);
10909 digest
[2] = byte_swap_32 (digest
[2]);
10910 digest
[3] = byte_swap_32 (digest
[3]);
10911 digest
[4] = byte_swap_32 (digest
[4]);
10913 digest
[0] -= SHA1M_A
;
10914 digest
[1] -= SHA1M_B
;
10915 digest
[2] -= SHA1M_C
;
10916 digest
[3] -= SHA1M_D
;
10917 digest
[4] -= SHA1M_E
;
10919 return (PARSER_OK
);
10922 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10924 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10926 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10928 if (c12
& 3) return (PARSER_HASH_VALUE
);
10930 u32
*digest
= (u32
*) hash_buf
->digest
;
10932 salt_t
*salt
= hash_buf
->salt
;
10934 // for ascii_digest
10935 salt
->salt_sign
[0] = input_buf
[0];
10936 salt
->salt_sign
[1] = input_buf
[1];
10938 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10939 | itoa64_to_int (input_buf
[1]) << 6;
10941 salt
->salt_len
= 2;
10943 u8 tmp_buf
[100] = { 0 };
10945 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10947 memcpy (digest
, tmp_buf
, 8);
10951 IP (digest
[0], digest
[1], tt
);
10956 return (PARSER_OK
);
10959 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10961 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10963 u32
*digest
= (u32
*) hash_buf
->digest
;
10965 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10966 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10967 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10968 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10970 digest
[0] = byte_swap_32 (digest
[0]);
10971 digest
[1] = byte_swap_32 (digest
[1]);
10972 digest
[2] = byte_swap_32 (digest
[2]);
10973 digest
[3] = byte_swap_32 (digest
[3]);
10975 digest
[0] -= MD4M_A
;
10976 digest
[1] -= MD4M_B
;
10977 digest
[2] -= MD4M_C
;
10978 digest
[3] -= MD4M_D
;
10980 return (PARSER_OK
);
10983 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10985 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10987 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10991 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10994 u32
*digest
= (u32
*) hash_buf
->digest
;
10996 salt_t
*salt
= hash_buf
->salt
;
10998 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10999 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11000 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11001 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11003 digest
[0] = byte_swap_32 (digest
[0]);
11004 digest
[1] = byte_swap_32 (digest
[1]);
11005 digest
[2] = byte_swap_32 (digest
[2]);
11006 digest
[3] = byte_swap_32 (digest
[3]);
11008 digest
[0] -= MD4M_A
;
11009 digest
[1] -= MD4M_B
;
11010 digest
[2] -= MD4M_C
;
11011 digest
[3] -= MD4M_D
;
11013 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11015 uint salt_len
= input_len
- 32 - 1;
11017 char *salt_buf
= input_buf
+ 32 + 1;
11019 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11025 salt
->salt_len
= salt_len
;
11027 return (PARSER_OK
);
11030 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11032 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11034 u32
*digest
= (u32
*) hash_buf
->digest
;
11036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11038 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11039 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11041 digest
[0] = byte_swap_32 (digest
[0]);
11042 digest
[1] = byte_swap_32 (digest
[1]);
11043 digest
[2] = byte_swap_32 (digest
[2]);
11044 digest
[3] = byte_swap_32 (digest
[3]);
11046 digest
[0] -= MD5M_A
;
11047 digest
[1] -= MD5M_B
;
11048 digest
[2] -= MD5M_C
;
11049 digest
[3] -= MD5M_D
;
11051 return (PARSER_OK
);
11054 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11056 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11058 u32
*digest
= (u32
*) hash_buf
->digest
;
11060 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11061 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11065 digest
[0] = byte_swap_32 (digest
[0]);
11066 digest
[1] = byte_swap_32 (digest
[1]);
11068 return (PARSER_OK
);
11071 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11073 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11075 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11079 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11082 u32
*digest
= (u32
*) hash_buf
->digest
;
11084 salt_t
*salt
= hash_buf
->salt
;
11086 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11087 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11088 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11089 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11091 digest
[0] = byte_swap_32 (digest
[0]);
11092 digest
[1] = byte_swap_32 (digest
[1]);
11093 digest
[2] = byte_swap_32 (digest
[2]);
11094 digest
[3] = byte_swap_32 (digest
[3]);
11096 digest
[0] -= MD5M_A
;
11097 digest
[1] -= MD5M_B
;
11098 digest
[2] -= MD5M_C
;
11099 digest
[3] -= MD5M_D
;
11101 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11103 uint salt_len
= input_len
- 32 - 1;
11105 char *salt_buf
= input_buf
+ 32 + 1;
11107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11113 salt
->salt_len
= salt_len
;
11115 return (PARSER_OK
);
11118 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11120 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11122 u32
*digest
= (u32
*) hash_buf
->digest
;
11124 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11125 | itoa64_to_int (input_buf
[ 1]) << 6
11126 | itoa64_to_int (input_buf
[ 2]) << 12
11127 | itoa64_to_int (input_buf
[ 3]) << 18;
11128 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11129 | itoa64_to_int (input_buf
[ 5]) << 6
11130 | itoa64_to_int (input_buf
[ 6]) << 12
11131 | itoa64_to_int (input_buf
[ 7]) << 18;
11132 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11133 | itoa64_to_int (input_buf
[ 9]) << 6
11134 | itoa64_to_int (input_buf
[10]) << 12
11135 | itoa64_to_int (input_buf
[11]) << 18;
11136 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11137 | itoa64_to_int (input_buf
[13]) << 6
11138 | itoa64_to_int (input_buf
[14]) << 12
11139 | itoa64_to_int (input_buf
[15]) << 18;
11141 digest
[0] -= MD5M_A
;
11142 digest
[1] -= MD5M_B
;
11143 digest
[2] -= MD5M_C
;
11144 digest
[3] -= MD5M_D
;
11146 digest
[0] &= 0x00ffffff;
11147 digest
[1] &= 0x00ffffff;
11148 digest
[2] &= 0x00ffffff;
11149 digest
[3] &= 0x00ffffff;
11151 return (PARSER_OK
);
11154 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11156 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11158 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11162 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11165 u32
*digest
= (u32
*) hash_buf
->digest
;
11167 salt_t
*salt
= hash_buf
->salt
;
11169 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11170 | itoa64_to_int (input_buf
[ 1]) << 6
11171 | itoa64_to_int (input_buf
[ 2]) << 12
11172 | itoa64_to_int (input_buf
[ 3]) << 18;
11173 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11174 | itoa64_to_int (input_buf
[ 5]) << 6
11175 | itoa64_to_int (input_buf
[ 6]) << 12
11176 | itoa64_to_int (input_buf
[ 7]) << 18;
11177 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11178 | itoa64_to_int (input_buf
[ 9]) << 6
11179 | itoa64_to_int (input_buf
[10]) << 12
11180 | itoa64_to_int (input_buf
[11]) << 18;
11181 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11182 | itoa64_to_int (input_buf
[13]) << 6
11183 | itoa64_to_int (input_buf
[14]) << 12
11184 | itoa64_to_int (input_buf
[15]) << 18;
11186 digest
[0] -= MD5M_A
;
11187 digest
[1] -= MD5M_B
;
11188 digest
[2] -= MD5M_C
;
11189 digest
[3] -= MD5M_D
;
11191 digest
[0] &= 0x00ffffff;
11192 digest
[1] &= 0x00ffffff;
11193 digest
[2] &= 0x00ffffff;
11194 digest
[3] &= 0x00ffffff;
11196 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11198 uint salt_len
= input_len
- 16 - 1;
11200 char *salt_buf
= input_buf
+ 16 + 1;
11202 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11204 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11206 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11208 salt
->salt_len
= salt_len
;
11210 return (PARSER_OK
);
11213 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11215 key
[0] = (nthash
[0] >> 0);
11216 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11217 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11218 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11219 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11220 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11221 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11222 key
[7] = (nthash
[6] << 1);
11234 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11236 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11238 u32
*digest
= (u32
*) hash_buf
->digest
;
11240 salt_t
*salt
= hash_buf
->salt
;
11242 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11248 char *user_pos
= input_buf
;
11250 char *unused_pos
= strchr (user_pos
, ':');
11252 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11254 uint user_len
= unused_pos
- user_pos
;
11256 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11260 char *domain_pos
= strchr (unused_pos
, ':');
11262 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11264 uint unused_len
= domain_pos
- unused_pos
;
11266 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11270 char *srvchall_pos
= strchr (domain_pos
, ':');
11272 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11274 uint domain_len
= srvchall_pos
- domain_pos
;
11276 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11280 char *hash_pos
= strchr (srvchall_pos
, ':');
11282 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11284 uint srvchall_len
= hash_pos
- srvchall_pos
;
11286 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11290 char *clichall_pos
= strchr (hash_pos
, ':');
11292 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11294 uint hash_len
= clichall_pos
- hash_pos
;
11296 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11300 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11302 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11305 * store some data for later use
11308 netntlm
->user_len
= user_len
* 2;
11309 netntlm
->domain_len
= domain_len
* 2;
11310 netntlm
->srvchall_len
= srvchall_len
/ 2;
11311 netntlm
->clichall_len
= clichall_len
/ 2;
11313 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11314 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11317 * handle username and domainname
11320 for (uint i
= 0; i
< user_len
; i
++)
11322 *userdomain_ptr
++ = user_pos
[i
];
11323 *userdomain_ptr
++ = 0;
11326 for (uint i
= 0; i
< domain_len
; i
++)
11328 *userdomain_ptr
++ = domain_pos
[i
];
11329 *userdomain_ptr
++ = 0;
11333 * handle server challenge encoding
11336 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11338 const char p0
= srvchall_pos
[i
+ 0];
11339 const char p1
= srvchall_pos
[i
+ 1];
11341 *chall_ptr
++ = hex_convert (p1
) << 0
11342 | hex_convert (p0
) << 4;
11346 * handle client challenge encoding
11349 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11351 const char p0
= clichall_pos
[i
+ 0];
11352 const char p1
= clichall_pos
[i
+ 1];
11354 *chall_ptr
++ = hex_convert (p1
) << 0
11355 | hex_convert (p0
) << 4;
11362 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11364 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11366 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11368 salt
->salt_len
= salt_len
;
11370 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11371 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11372 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11373 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11375 digest
[0] = byte_swap_32 (digest
[0]);
11376 digest
[1] = byte_swap_32 (digest
[1]);
11377 digest
[2] = byte_swap_32 (digest
[2]);
11378 digest
[3] = byte_swap_32 (digest
[3]);
11380 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11382 uint digest_tmp
[2] = { 0 };
11384 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11385 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11387 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11388 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11390 /* special case 2: ESS */
11392 if (srvchall_len
== 48)
11394 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11396 uint w
[16] = { 0 };
11398 w
[ 0] = netntlm
->chall_buf
[6];
11399 w
[ 1] = netntlm
->chall_buf
[7];
11400 w
[ 2] = netntlm
->chall_buf
[0];
11401 w
[ 3] = netntlm
->chall_buf
[1];
11405 uint dgst
[4] = { 0 };
11414 salt
->salt_buf
[0] = dgst
[0];
11415 salt
->salt_buf
[1] = dgst
[1];
11419 /* precompute netntlmv1 exploit start */
11421 for (uint i
= 0; i
< 0x10000; i
++)
11423 uint key_md4
[2] = { i
, 0 };
11424 uint key_des
[2] = { 0, 0 };
11426 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11428 uint Kc
[16] = { 0 };
11429 uint Kd
[16] = { 0 };
11431 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11433 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11435 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11437 if (data3
[0] != digest_tmp
[0]) continue;
11438 if (data3
[1] != digest_tmp
[1]) continue;
11440 salt
->salt_buf
[2] = i
;
11442 salt
->salt_len
= 24;
11447 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11448 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11450 /* precompute netntlmv1 exploit stop */
11454 IP (digest
[0], digest
[1], tt
);
11455 IP (digest
[2], digest
[3], tt
);
11457 digest
[0] = rotr32 (digest
[0], 29);
11458 digest
[1] = rotr32 (digest
[1], 29);
11459 digest
[2] = rotr32 (digest
[2], 29);
11460 digest
[3] = rotr32 (digest
[3], 29);
11462 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11464 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11465 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11467 return (PARSER_OK
);
11470 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11472 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11474 u32
*digest
= (u32
*) hash_buf
->digest
;
11476 salt_t
*salt
= hash_buf
->salt
;
11478 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11484 char *user_pos
= input_buf
;
11486 char *unused_pos
= strchr (user_pos
, ':');
11488 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11490 uint user_len
= unused_pos
- user_pos
;
11492 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11496 char *domain_pos
= strchr (unused_pos
, ':');
11498 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11500 uint unused_len
= domain_pos
- unused_pos
;
11502 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11506 char *srvchall_pos
= strchr (domain_pos
, ':');
11508 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11510 uint domain_len
= srvchall_pos
- domain_pos
;
11512 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11516 char *hash_pos
= strchr (srvchall_pos
, ':');
11518 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11520 uint srvchall_len
= hash_pos
- srvchall_pos
;
11522 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11526 char *clichall_pos
= strchr (hash_pos
, ':');
11528 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11530 uint hash_len
= clichall_pos
- hash_pos
;
11532 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11536 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11538 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11540 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11543 * store some data for later use
11546 netntlm
->user_len
= user_len
* 2;
11547 netntlm
->domain_len
= domain_len
* 2;
11548 netntlm
->srvchall_len
= srvchall_len
/ 2;
11549 netntlm
->clichall_len
= clichall_len
/ 2;
11551 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11552 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11555 * handle username and domainname
11558 for (uint i
= 0; i
< user_len
; i
++)
11560 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11561 *userdomain_ptr
++ = 0;
11564 for (uint i
= 0; i
< domain_len
; i
++)
11566 *userdomain_ptr
++ = domain_pos
[i
];
11567 *userdomain_ptr
++ = 0;
11570 *userdomain_ptr
++ = 0x80;
11573 * handle server challenge encoding
11576 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11578 const char p0
= srvchall_pos
[i
+ 0];
11579 const char p1
= srvchall_pos
[i
+ 1];
11581 *chall_ptr
++ = hex_convert (p1
) << 0
11582 | hex_convert (p0
) << 4;
11586 * handle client challenge encoding
11589 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11591 const char p0
= clichall_pos
[i
+ 0];
11592 const char p1
= clichall_pos
[i
+ 1];
11594 *chall_ptr
++ = hex_convert (p1
) << 0
11595 | hex_convert (p0
) << 4;
11598 *chall_ptr
++ = 0x80;
11601 * handle hash itself
11604 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11605 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11606 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11607 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11609 digest
[0] = byte_swap_32 (digest
[0]);
11610 digest
[1] = byte_swap_32 (digest
[1]);
11611 digest
[2] = byte_swap_32 (digest
[2]);
11612 digest
[3] = byte_swap_32 (digest
[3]);
11615 * reuse challange data as salt_buf, its the buffer that is most likely unique
11618 salt
->salt_buf
[0] = 0;
11619 salt
->salt_buf
[1] = 0;
11620 salt
->salt_buf
[2] = 0;
11621 salt
->salt_buf
[3] = 0;
11622 salt
->salt_buf
[4] = 0;
11623 salt
->salt_buf
[5] = 0;
11624 salt
->salt_buf
[6] = 0;
11625 salt
->salt_buf
[7] = 0;
11629 uptr
= (uint
*) netntlm
->userdomain_buf
;
11631 for (uint i
= 0; i
< 16; i
+= 16)
11633 md5_64 (uptr
, salt
->salt_buf
);
11636 uptr
= (uint
*) netntlm
->chall_buf
;
11638 for (uint i
= 0; i
< 256; i
+= 16)
11640 md5_64 (uptr
, salt
->salt_buf
);
11643 salt
->salt_len
= 16;
11645 return (PARSER_OK
);
11648 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11650 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11652 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11656 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11659 u32
*digest
= (u32
*) hash_buf
->digest
;
11661 salt_t
*salt
= hash_buf
->salt
;
11663 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11664 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11665 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11666 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11668 digest
[0] = byte_swap_32 (digest
[0]);
11669 digest
[1] = byte_swap_32 (digest
[1]);
11670 digest
[2] = byte_swap_32 (digest
[2]);
11671 digest
[3] = byte_swap_32 (digest
[3]);
11673 digest
[0] -= MD5M_A
;
11674 digest
[1] -= MD5M_B
;
11675 digest
[2] -= MD5M_C
;
11676 digest
[3] -= MD5M_D
;
11678 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11680 uint salt_len
= input_len
- 32 - 1;
11682 char *salt_buf
= input_buf
+ 32 + 1;
11684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11686 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11688 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11690 salt
->salt_len
= salt_len
;
11692 return (PARSER_OK
);
11695 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11697 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11699 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11703 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11706 u32
*digest
= (u32
*) hash_buf
->digest
;
11708 salt_t
*salt
= hash_buf
->salt
;
11710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11715 digest
[0] = byte_swap_32 (digest
[0]);
11716 digest
[1] = byte_swap_32 (digest
[1]);
11717 digest
[2] = byte_swap_32 (digest
[2]);
11718 digest
[3] = byte_swap_32 (digest
[3]);
11720 digest
[0] -= MD5M_A
;
11721 digest
[1] -= MD5M_B
;
11722 digest
[2] -= MD5M_C
;
11723 digest
[3] -= MD5M_D
;
11725 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11727 uint salt_len
= input_len
- 32 - 1;
11729 char *salt_buf
= input_buf
+ 32 + 1;
11731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11733 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11737 salt
->salt_len
= salt_len
;
11739 return (PARSER_OK
);
11742 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11744 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11746 u32
*digest
= (u32
*) hash_buf
->digest
;
11748 salt_t
*salt
= hash_buf
->salt
;
11750 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11751 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11752 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11753 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11755 digest
[0] = byte_swap_32 (digest
[0]);
11756 digest
[1] = byte_swap_32 (digest
[1]);
11757 digest
[2] = byte_swap_32 (digest
[2]);
11758 digest
[3] = byte_swap_32 (digest
[3]);
11760 digest
[0] -= MD5M_A
;
11761 digest
[1] -= MD5M_B
;
11762 digest
[2] -= MD5M_C
;
11763 digest
[3] -= MD5M_D
;
11766 * This is a virtual salt. While the algorithm is basically not salted
11767 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11768 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11773 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11775 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11777 salt
->salt_len
= salt_len
;
11779 return (PARSER_OK
);
11782 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11784 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11786 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11790 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11793 u32
*digest
= (u32
*) hash_buf
->digest
;
11795 salt_t
*salt
= hash_buf
->salt
;
11797 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11798 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11799 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11800 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11802 digest
[0] = byte_swap_32 (digest
[0]);
11803 digest
[1] = byte_swap_32 (digest
[1]);
11804 digest
[2] = byte_swap_32 (digest
[2]);
11805 digest
[3] = byte_swap_32 (digest
[3]);
11807 digest
[0] -= MD5M_A
;
11808 digest
[1] -= MD5M_B
;
11809 digest
[2] -= MD5M_C
;
11810 digest
[3] -= MD5M_D
;
11812 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11814 uint salt_len
= input_len
- 32 - 1;
11816 char *salt_buf
= input_buf
+ 32 + 1;
11818 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11820 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11822 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11824 salt
->salt_len
= salt_len
;
11826 return (PARSER_OK
);
11829 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11831 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11833 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11837 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11840 u32
*digest
= (u32
*) hash_buf
->digest
;
11842 salt_t
*salt
= hash_buf
->salt
;
11844 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11845 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11846 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11847 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11849 digest
[0] = byte_swap_32 (digest
[0]);
11850 digest
[1] = byte_swap_32 (digest
[1]);
11851 digest
[2] = byte_swap_32 (digest
[2]);
11852 digest
[3] = byte_swap_32 (digest
[3]);
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 dcc_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_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11879 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) 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 digest
[0] -= MD4M_A
;
11897 digest
[1] -= MD4M_B
;
11898 digest
[2] -= MD4M_C
;
11899 digest
[3] -= MD4M_D
;
11901 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11903 uint salt_len
= input_len
- 32 - 1;
11905 char *salt_buf
= input_buf
+ 32 + 1;
11907 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11909 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11911 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11913 salt
->salt_len
= salt_len
;
11915 return (PARSER_OK
);
11918 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11920 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11922 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11926 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11929 u32
*digest
= (u32
*) hash_buf
->digest
;
11931 salt_t
*salt
= hash_buf
->salt
;
11933 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11934 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11935 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11936 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11938 digest
[0] = byte_swap_32 (digest
[0]);
11939 digest
[1] = byte_swap_32 (digest
[1]);
11940 digest
[2] = byte_swap_32 (digest
[2]);
11941 digest
[3] = byte_swap_32 (digest
[3]);
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 uint salt_pc_block
[16] = { 0 };
11951 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11953 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11955 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11957 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11959 salt_pc_block
[14] = salt_len
* 8;
11961 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11963 md5_64 (salt_pc_block
, salt_pc_digest
);
11965 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11966 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11967 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11968 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11970 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11972 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11974 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11976 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11977 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11978 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11979 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11981 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11983 return (PARSER_OK
);
11986 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11988 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11990 u32
*digest
= (u32
*) hash_buf
->digest
;
11992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11996 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11998 digest
[0] -= SHA1M_A
;
11999 digest
[1] -= SHA1M_B
;
12000 digest
[2] -= SHA1M_C
;
12001 digest
[3] -= SHA1M_D
;
12002 digest
[4] -= SHA1M_E
;
12004 return (PARSER_OK
);
12007 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12009 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12011 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12013 u32
*digest
= (u32
*) hash_buf
->digest
;
12017 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12018 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12019 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12020 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12023 return (PARSER_OK
);
12026 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12028 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12030 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12034 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12037 u32
*digest
= (u32
*) hash_buf
->digest
;
12039 salt_t
*salt
= hash_buf
->salt
;
12041 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12042 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12043 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12044 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12045 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12047 digest
[0] -= SHA1M_A
;
12048 digest
[1] -= SHA1M_B
;
12049 digest
[2] -= SHA1M_C
;
12050 digest
[3] -= SHA1M_D
;
12051 digest
[4] -= SHA1M_E
;
12053 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12055 uint salt_len
= input_len
- 40 - 1;
12057 char *salt_buf
= input_buf
+ 40 + 1;
12059 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12061 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12063 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12065 salt
->salt_len
= salt_len
;
12067 return (PARSER_OK
);
12070 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12072 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12074 u32
*digest
= (u32
*) hash_buf
->digest
;
12076 salt_t
*salt
= hash_buf
->salt
;
12078 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12080 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12081 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12082 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12083 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12084 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12086 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12088 uint salt_len
= input_len
- 40 - 1;
12090 char *salt_buf
= input_buf
+ 40 + 1;
12092 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12094 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12096 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12098 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12101 pstoken
->salt_len
= salt_len
/ 2;
12103 /* some fake salt for the sorting mechanisms */
12105 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12106 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12107 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12108 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12109 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12110 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12111 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12112 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12114 salt
->salt_len
= 32;
12116 /* we need to check if we can precompute some of the data --
12117 this is possible since the scheme is badly designed */
12119 pstoken
->pc_digest
[0] = SHA1M_A
;
12120 pstoken
->pc_digest
[1] = SHA1M_B
;
12121 pstoken
->pc_digest
[2] = SHA1M_C
;
12122 pstoken
->pc_digest
[3] = SHA1M_D
;
12123 pstoken
->pc_digest
[4] = SHA1M_E
;
12125 pstoken
->pc_offset
= 0;
12127 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12131 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12132 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12133 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12134 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12135 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12136 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12137 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12138 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12139 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12140 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12141 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12142 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12143 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12144 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12145 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12146 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12148 sha1_64 (w
, pstoken
->pc_digest
);
12150 pstoken
->pc_offset
+= 16;
12153 return (PARSER_OK
);
12156 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12158 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12160 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12162 u32
*digest
= (u32
*) hash_buf
->digest
;
12164 u8 tmp_buf
[100] = { 0 };
12166 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12168 memcpy (digest
, tmp_buf
, 20);
12170 digest
[0] = byte_swap_32 (digest
[0]);
12171 digest
[1] = byte_swap_32 (digest
[1]);
12172 digest
[2] = byte_swap_32 (digest
[2]);
12173 digest
[3] = byte_swap_32 (digest
[3]);
12174 digest
[4] = byte_swap_32 (digest
[4]);
12176 digest
[0] -= SHA1M_A
;
12177 digest
[1] -= SHA1M_B
;
12178 digest
[2] -= SHA1M_C
;
12179 digest
[3] -= SHA1M_D
;
12180 digest
[4] -= SHA1M_E
;
12182 return (PARSER_OK
);
12185 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12187 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12189 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12191 u32
*digest
= (u32
*) hash_buf
->digest
;
12193 salt_t
*salt
= hash_buf
->salt
;
12195 u8 tmp_buf
[100] = { 0 };
12197 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12199 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12201 memcpy (digest
, tmp_buf
, 20);
12203 int salt_len
= tmp_len
- 20;
12205 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12207 salt
->salt_len
= salt_len
;
12209 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12211 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12213 char *ptr
= (char *) salt
->salt_buf
;
12215 ptr
[salt
->salt_len
] = 0x80;
12218 digest
[0] = byte_swap_32 (digest
[0]);
12219 digest
[1] = byte_swap_32 (digest
[1]);
12220 digest
[2] = byte_swap_32 (digest
[2]);
12221 digest
[3] = byte_swap_32 (digest
[3]);
12222 digest
[4] = byte_swap_32 (digest
[4]);
12224 digest
[0] -= SHA1M_A
;
12225 digest
[1] -= SHA1M_B
;
12226 digest
[2] -= SHA1M_C
;
12227 digest
[3] -= SHA1M_D
;
12228 digest
[4] -= SHA1M_E
;
12230 return (PARSER_OK
);
12233 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12235 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12237 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12239 u32
*digest
= (u32
*) hash_buf
->digest
;
12241 salt_t
*salt
= hash_buf
->salt
;
12243 char *salt_buf
= input_buf
+ 6;
12247 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12249 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12251 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12253 salt
->salt_len
= salt_len
;
12255 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12257 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12258 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12259 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12260 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12261 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12263 digest
[0] -= SHA1M_A
;
12264 digest
[1] -= SHA1M_B
;
12265 digest
[2] -= SHA1M_C
;
12266 digest
[3] -= SHA1M_D
;
12267 digest
[4] -= SHA1M_E
;
12269 return (PARSER_OK
);
12272 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12274 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12276 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12278 u32
*digest
= (u32
*) hash_buf
->digest
;
12280 salt_t
*salt
= hash_buf
->salt
;
12282 char *salt_buf
= input_buf
+ 6;
12286 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12288 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12290 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12292 salt
->salt_len
= salt_len
;
12294 char *hash_pos
= input_buf
+ 6 + 8;
12296 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12297 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12298 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12299 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12300 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12302 digest
[0] -= SHA1M_A
;
12303 digest
[1] -= SHA1M_B
;
12304 digest
[2] -= SHA1M_C
;
12305 digest
[3] -= SHA1M_D
;
12306 digest
[4] -= SHA1M_E
;
12308 return (PARSER_OK
);
12311 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12313 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12315 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12317 u64
*digest
= (u64
*) hash_buf
->digest
;
12319 salt_t
*salt
= hash_buf
->salt
;
12321 char *salt_buf
= input_buf
+ 6;
12325 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12327 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12329 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12331 salt
->salt_len
= salt_len
;
12333 char *hash_pos
= input_buf
+ 6 + 8;
12335 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12336 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12337 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12338 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12339 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12340 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12341 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12342 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12344 digest
[0] -= SHA512M_A
;
12345 digest
[1] -= SHA512M_B
;
12346 digest
[2] -= SHA512M_C
;
12347 digest
[3] -= SHA512M_D
;
12348 digest
[4] -= SHA512M_E
;
12349 digest
[5] -= SHA512M_F
;
12350 digest
[6] -= SHA512M_G
;
12351 digest
[7] -= SHA512M_H
;
12353 return (PARSER_OK
);
12356 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12358 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12360 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12364 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12367 u32
*digest
= (u32
*) hash_buf
->digest
;
12369 salt_t
*salt
= hash_buf
->salt
;
12371 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12372 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12376 digest
[0] = byte_swap_32 (digest
[0]);
12377 digest
[1] = byte_swap_32 (digest
[1]);
12379 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12381 uint salt_len
= input_len
- 16 - 1;
12383 char *salt_buf
= input_buf
+ 16 + 1;
12385 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12387 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12391 salt
->salt_len
= salt_len
;
12393 return (PARSER_OK
);
12396 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12398 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12400 u32
*digest
= (u32
*) hash_buf
->digest
;
12402 salt_t
*salt
= hash_buf
->salt
;
12404 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12405 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12406 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12407 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12408 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12410 digest
[0] -= SHA1M_A
;
12411 digest
[1] -= SHA1M_B
;
12412 digest
[2] -= SHA1M_C
;
12413 digest
[3] -= SHA1M_D
;
12414 digest
[4] -= SHA1M_E
;
12416 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12418 uint salt_len
= input_len
- 40 - 1;
12420 char *salt_buf
= input_buf
+ 40 + 1;
12422 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12424 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12426 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12428 salt
->salt_len
= salt_len
;
12430 return (PARSER_OK
);
12433 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12435 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12437 u32
*digest
= (u32
*) hash_buf
->digest
;
12439 salt_t
*salt
= hash_buf
->salt
;
12441 char *hash_pos
= input_buf
;
12443 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12444 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12445 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12446 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12447 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12448 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12449 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12450 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12451 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12452 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12453 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12454 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12455 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12456 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12457 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12458 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12460 char *salt_pos
= input_buf
+ 128;
12462 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12463 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12464 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12465 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12467 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12468 salt
->salt_len
= 16;
12470 return (PARSER_OK
);
12473 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12475 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12477 u32
*digest
= (u32
*) hash_buf
->digest
;
12479 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12480 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12481 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12482 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12483 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12484 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12485 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12486 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12488 digest
[0] -= SHA256M_A
;
12489 digest
[1] -= SHA256M_B
;
12490 digest
[2] -= SHA256M_C
;
12491 digest
[3] -= SHA256M_D
;
12492 digest
[4] -= SHA256M_E
;
12493 digest
[5] -= SHA256M_F
;
12494 digest
[6] -= SHA256M_G
;
12495 digest
[7] -= SHA256M_H
;
12497 return (PARSER_OK
);
12500 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12502 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12504 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12508 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12511 u32
*digest
= (u32
*) hash_buf
->digest
;
12513 salt_t
*salt
= hash_buf
->salt
;
12515 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12516 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12517 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12518 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12519 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12520 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12521 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12522 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12524 digest
[0] -= SHA256M_A
;
12525 digest
[1] -= SHA256M_B
;
12526 digest
[2] -= SHA256M_C
;
12527 digest
[3] -= SHA256M_D
;
12528 digest
[4] -= SHA256M_E
;
12529 digest
[5] -= SHA256M_F
;
12530 digest
[6] -= SHA256M_G
;
12531 digest
[7] -= SHA256M_H
;
12533 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12535 uint salt_len
= input_len
- 64 - 1;
12537 char *salt_buf
= input_buf
+ 64 + 1;
12539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12541 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12543 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12545 salt
->salt_len
= salt_len
;
12547 return (PARSER_OK
);
12550 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12552 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12554 u64
*digest
= (u64
*) hash_buf
->digest
;
12556 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12557 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12558 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12559 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12560 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12561 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12565 digest
[0] -= SHA384M_A
;
12566 digest
[1] -= SHA384M_B
;
12567 digest
[2] -= SHA384M_C
;
12568 digest
[3] -= SHA384M_D
;
12569 digest
[4] -= SHA384M_E
;
12570 digest
[5] -= SHA384M_F
;
12574 return (PARSER_OK
);
12577 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12579 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12581 u64
*digest
= (u64
*) hash_buf
->digest
;
12583 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12584 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12585 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12586 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12587 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12588 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12589 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12590 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12592 digest
[0] -= SHA512M_A
;
12593 digest
[1] -= SHA512M_B
;
12594 digest
[2] -= SHA512M_C
;
12595 digest
[3] -= SHA512M_D
;
12596 digest
[4] -= SHA512M_E
;
12597 digest
[5] -= SHA512M_F
;
12598 digest
[6] -= SHA512M_G
;
12599 digest
[7] -= SHA512M_H
;
12601 return (PARSER_OK
);
12604 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12606 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12608 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12612 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12615 u64
*digest
= (u64
*) hash_buf
->digest
;
12617 salt_t
*salt
= hash_buf
->salt
;
12619 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12620 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12621 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12622 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12623 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12624 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12625 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12626 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12628 digest
[0] -= SHA512M_A
;
12629 digest
[1] -= SHA512M_B
;
12630 digest
[2] -= SHA512M_C
;
12631 digest
[3] -= SHA512M_D
;
12632 digest
[4] -= SHA512M_E
;
12633 digest
[5] -= SHA512M_F
;
12634 digest
[6] -= SHA512M_G
;
12635 digest
[7] -= SHA512M_H
;
12637 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12639 uint salt_len
= input_len
- 128 - 1;
12641 char *salt_buf
= input_buf
+ 128 + 1;
12643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12645 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12647 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12649 salt
->salt_len
= salt_len
;
12651 return (PARSER_OK
);
12654 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12656 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12658 u64
*digest
= (u64
*) hash_buf
->digest
;
12660 salt_t
*salt
= hash_buf
->salt
;
12662 char *salt_pos
= input_buf
+ 3;
12664 uint iterations_len
= 0;
12666 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12670 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12672 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12673 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12677 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12681 iterations_len
+= 8;
12685 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12688 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12690 char *hash_pos
= strchr (salt_pos
, '$');
12692 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12694 uint salt_len
= hash_pos
- salt_pos
;
12696 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12698 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12700 salt
->salt_len
= salt_len
;
12704 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12706 return (PARSER_OK
);
12709 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12711 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12713 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12715 u64
*digest
= (u64
*) hash_buf
->digest
;
12717 salt_t
*salt
= hash_buf
->salt
;
12719 uint keccak_mdlen
= input_len
/ 2;
12721 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12723 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12725 digest
[i
] = byte_swap_64 (digest
[i
]);
12728 salt
->keccak_mdlen
= keccak_mdlen
;
12730 return (PARSER_OK
);
12733 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12735 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12737 u32
*digest
= (u32
*) hash_buf
->digest
;
12739 salt_t
*salt
= hash_buf
->salt
;
12741 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12744 * Parse that strange long line
12749 size_t in_len
[9] = { 0 };
12751 in_off
[0] = strtok (input_buf
, ":");
12753 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12755 in_len
[0] = strlen (in_off
[0]);
12759 for (i
= 1; i
< 9; i
++)
12761 in_off
[i
] = strtok (NULL
, ":");
12763 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12765 in_len
[i
] = strlen (in_off
[i
]);
12768 char *ptr
= (char *) ikepsk
->msg_buf
;
12770 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12771 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12772 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12773 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12774 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12775 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12779 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12781 ptr
= (char *) ikepsk
->nr_buf
;
12783 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12784 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12788 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12791 * Store to database
12796 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12797 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12798 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12799 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12801 digest
[0] = byte_swap_32 (digest
[0]);
12802 digest
[1] = byte_swap_32 (digest
[1]);
12803 digest
[2] = byte_swap_32 (digest
[2]);
12804 digest
[3] = byte_swap_32 (digest
[3]);
12806 salt
->salt_len
= 32;
12808 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12809 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12810 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12811 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12812 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12813 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12814 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12815 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12817 return (PARSER_OK
);
12820 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12822 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12824 u32
*digest
= (u32
*) hash_buf
->digest
;
12826 salt_t
*salt
= hash_buf
->salt
;
12828 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12831 * Parse that strange long line
12836 size_t in_len
[9] = { 0 };
12838 in_off
[0] = strtok (input_buf
, ":");
12840 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12842 in_len
[0] = strlen (in_off
[0]);
12846 for (i
= 1; i
< 9; i
++)
12848 in_off
[i
] = strtok (NULL
, ":");
12850 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12852 in_len
[i
] = strlen (in_off
[i
]);
12855 char *ptr
= (char *) ikepsk
->msg_buf
;
12857 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12858 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12859 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12860 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12861 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12862 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12866 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12868 ptr
= (char *) ikepsk
->nr_buf
;
12870 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12871 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12875 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12878 * Store to database
12883 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12884 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12885 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12886 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12887 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12889 salt
->salt_len
= 32;
12891 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12892 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12893 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12894 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12895 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12896 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12897 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12898 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12900 return (PARSER_OK
);
12903 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12905 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12907 u32
*digest
= (u32
*) hash_buf
->digest
;
12909 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12910 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12911 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12912 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12913 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12915 digest
[0] = byte_swap_32 (digest
[0]);
12916 digest
[1] = byte_swap_32 (digest
[1]);
12917 digest
[2] = byte_swap_32 (digest
[2]);
12918 digest
[3] = byte_swap_32 (digest
[3]);
12919 digest
[4] = byte_swap_32 (digest
[4]);
12921 return (PARSER_OK
);
12924 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12926 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12928 u32
*digest
= (u32
*) hash_buf
->digest
;
12930 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12931 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12932 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12933 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12934 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12935 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12936 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12937 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12938 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12939 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12940 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12941 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12942 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12943 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12944 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12945 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12947 return (PARSER_OK
);
12950 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12952 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12954 u32
*digest
= (u32
*) hash_buf
->digest
;
12956 salt_t
*salt
= hash_buf
->salt
;
12958 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12959 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12960 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12961 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12962 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12964 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12966 uint salt_len
= input_len
- 40 - 1;
12968 char *salt_buf
= input_buf
+ 40 + 1;
12970 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12972 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12974 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12976 salt
->salt_len
= salt_len
;
12978 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12980 return (PARSER_OK
);
12983 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12985 u32
*digest
= (u32
*) hash_buf
->digest
;
12987 salt_t
*salt
= hash_buf
->salt
;
12989 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12991 if (input_len
== 0)
12993 log_error ("TrueCrypt container not specified");
12998 FILE *fp
= fopen (input_buf
, "rb");
13002 log_error ("%s: %s", input_buf
, strerror (errno
));
13007 char buf
[512] = { 0 };
13009 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13013 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13015 memcpy (tc
->salt_buf
, buf
, 64);
13017 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13019 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13021 salt
->salt_len
= 4;
13023 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13025 tc
->signature
= 0x45555254; // "TRUE"
13027 digest
[0] = tc
->data_buf
[0];
13029 return (PARSER_OK
);
13032 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13034 u32
*digest
= (u32
*) hash_buf
->digest
;
13036 salt_t
*salt
= hash_buf
->salt
;
13038 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13040 if (input_len
== 0)
13042 log_error ("TrueCrypt container not specified");
13047 FILE *fp
= fopen (input_buf
, "rb");
13051 log_error ("%s: %s", input_buf
, strerror (errno
));
13056 char buf
[512] = { 0 };
13058 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13062 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13064 memcpy (tc
->salt_buf
, buf
, 64);
13066 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13068 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13070 salt
->salt_len
= 4;
13072 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13074 tc
->signature
= 0x45555254; // "TRUE"
13076 digest
[0] = tc
->data_buf
[0];
13078 return (PARSER_OK
);
13081 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13083 u32
*digest
= (u32
*) hash_buf
->digest
;
13085 salt_t
*salt
= hash_buf
->salt
;
13087 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13089 if (input_len
== 0)
13091 log_error ("VeraCrypt container not specified");
13096 FILE *fp
= fopen (input_buf
, "rb");
13100 log_error ("%s: %s", input_buf
, strerror (errno
));
13105 char buf
[512] = { 0 };
13107 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13111 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13113 memcpy (tc
->salt_buf
, buf
, 64);
13115 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13117 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13119 salt
->salt_len
= 4;
13121 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13123 tc
->signature
= 0x41524556; // "VERA"
13125 digest
[0] = tc
->data_buf
[0];
13127 return (PARSER_OK
);
13130 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13132 u32
*digest
= (u32
*) hash_buf
->digest
;
13134 salt_t
*salt
= hash_buf
->salt
;
13136 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13138 if (input_len
== 0)
13140 log_error ("VeraCrypt container not specified");
13145 FILE *fp
= fopen (input_buf
, "rb");
13149 log_error ("%s: %s", input_buf
, strerror (errno
));
13154 char buf
[512] = { 0 };
13156 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13160 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13162 memcpy (tc
->salt_buf
, buf
, 64);
13164 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13166 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13168 salt
->salt_len
= 4;
13170 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13172 tc
->signature
= 0x41524556; // "VERA"
13174 digest
[0] = tc
->data_buf
[0];
13176 return (PARSER_OK
);
13179 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13181 u32
*digest
= (u32
*) hash_buf
->digest
;
13183 salt_t
*salt
= hash_buf
->salt
;
13185 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13187 if (input_len
== 0)
13189 log_error ("VeraCrypt container not specified");
13194 FILE *fp
= fopen (input_buf
, "rb");
13198 log_error ("%s: %s", input_buf
, strerror (errno
));
13203 char buf
[512] = { 0 };
13205 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13209 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13211 memcpy (tc
->salt_buf
, buf
, 64);
13213 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13215 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13217 salt
->salt_len
= 4;
13219 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13221 tc
->signature
= 0x41524556; // "VERA"
13223 digest
[0] = tc
->data_buf
[0];
13225 return (PARSER_OK
);
13228 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13230 u32
*digest
= (u32
*) hash_buf
->digest
;
13232 salt_t
*salt
= hash_buf
->salt
;
13234 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13236 if (input_len
== 0)
13238 log_error ("VeraCrypt container not specified");
13243 FILE *fp
= fopen (input_buf
, "rb");
13247 log_error ("%s: %s", input_buf
, strerror (errno
));
13252 char buf
[512] = { 0 };
13254 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13258 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13260 memcpy (tc
->salt_buf
, buf
, 64);
13262 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13264 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13266 salt
->salt_len
= 4;
13268 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13270 tc
->signature
= 0x41524556; // "VERA"
13272 digest
[0] = tc
->data_buf
[0];
13274 return (PARSER_OK
);
13277 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13279 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13281 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13283 u32
*digest
= (u32
*) hash_buf
->digest
;
13285 salt_t
*salt
= hash_buf
->salt
;
13287 char *salt_pos
= input_buf
+ 6;
13289 char *hash_pos
= strchr (salt_pos
, '$');
13291 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13293 uint salt_len
= hash_pos
- salt_pos
;
13295 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13297 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13299 salt
->salt_len
= salt_len
;
13301 salt
->salt_iter
= 1000;
13305 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13307 return (PARSER_OK
);
13310 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13312 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13314 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13316 u32
*digest
= (u32
*) hash_buf
->digest
;
13318 salt_t
*salt
= hash_buf
->salt
;
13320 char *iter_pos
= input_buf
+ 7;
13322 char *salt_pos
= strchr (iter_pos
, '$');
13324 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13328 char *hash_pos
= strchr (salt_pos
, '$');
13330 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13332 uint salt_len
= hash_pos
- salt_pos
;
13334 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13336 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13338 salt
->salt_len
= salt_len
;
13340 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13342 salt
->salt_sign
[0] = atoi (salt_iter
);
13344 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13348 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13350 digest
[0] = byte_swap_32 (digest
[0]);
13351 digest
[1] = byte_swap_32 (digest
[1]);
13352 digest
[2] = byte_swap_32 (digest
[2]);
13353 digest
[3] = byte_swap_32 (digest
[3]);
13354 digest
[4] = byte_swap_32 (digest
[4]);
13356 return (PARSER_OK
);
13359 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13361 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13363 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13365 u32
*digest
= (u32
*) hash_buf
->digest
;
13367 salt_t
*salt
= hash_buf
->salt
;
13369 char *iter_pos
= input_buf
+ 9;
13371 char *salt_pos
= strchr (iter_pos
, '$');
13373 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13377 char *hash_pos
= strchr (salt_pos
, '$');
13379 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13381 uint salt_len
= hash_pos
- salt_pos
;
13383 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13385 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13387 salt
->salt_len
= salt_len
;
13389 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13391 salt
->salt_sign
[0] = atoi (salt_iter
);
13393 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13397 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13399 digest
[0] = byte_swap_32 (digest
[0]);
13400 digest
[1] = byte_swap_32 (digest
[1]);
13401 digest
[2] = byte_swap_32 (digest
[2]);
13402 digest
[3] = byte_swap_32 (digest
[3]);
13403 digest
[4] = byte_swap_32 (digest
[4]);
13404 digest
[5] = byte_swap_32 (digest
[5]);
13405 digest
[6] = byte_swap_32 (digest
[6]);
13406 digest
[7] = byte_swap_32 (digest
[7]);
13408 return (PARSER_OK
);
13411 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13413 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13415 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13417 u64
*digest
= (u64
*) hash_buf
->digest
;
13419 salt_t
*salt
= hash_buf
->salt
;
13421 char *iter_pos
= input_buf
+ 9;
13423 char *salt_pos
= strchr (iter_pos
, '$');
13425 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13429 char *hash_pos
= strchr (salt_pos
, '$');
13431 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13433 uint salt_len
= hash_pos
- salt_pos
;
13435 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13437 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13439 salt
->salt_len
= salt_len
;
13441 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13443 salt
->salt_sign
[0] = atoi (salt_iter
);
13445 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13449 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13451 digest
[0] = byte_swap_64 (digest
[0]);
13452 digest
[1] = byte_swap_64 (digest
[1]);
13453 digest
[2] = byte_swap_64 (digest
[2]);
13454 digest
[3] = byte_swap_64 (digest
[3]);
13455 digest
[4] = byte_swap_64 (digest
[4]);
13456 digest
[5] = byte_swap_64 (digest
[5]);
13457 digest
[6] = byte_swap_64 (digest
[6]);
13458 digest
[7] = byte_swap_64 (digest
[7]);
13460 return (PARSER_OK
);
13463 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13465 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13467 u32
*digest
= (u32
*) hash_buf
->digest
;
13469 salt_t
*salt
= hash_buf
->salt
;
13471 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13477 char *iterations_pos
= input_buf
;
13479 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13481 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13483 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13485 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13489 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13491 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13493 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13495 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13497 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13499 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13504 * pbkdf2 iterations
13507 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13510 * handle salt encoding
13513 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13515 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13517 const char p0
= saltbuf_pos
[i
+ 0];
13518 const char p1
= saltbuf_pos
[i
+ 1];
13520 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13521 | hex_convert (p0
) << 4;
13524 salt
->salt_len
= saltbuf_len
/ 2;
13527 * handle cipher encoding
13530 uint
*tmp
= (uint
*) mymalloc (32);
13532 char *cipherbuf_ptr
= (char *) tmp
;
13534 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13536 const char p0
= cipherbuf_pos
[i
+ 0];
13537 const char p1
= cipherbuf_pos
[i
+ 1];
13539 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13540 | hex_convert (p0
) << 4;
13543 // iv is stored at salt_buf 4 (length 16)
13544 // data is stored at salt_buf 8 (length 16)
13546 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13547 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13548 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13549 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13551 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13552 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13553 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13554 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13558 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13560 const char p0
= cipherbuf_pos
[j
+ 0];
13561 const char p1
= cipherbuf_pos
[j
+ 1];
13563 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13564 | hex_convert (p0
) << 4;
13571 digest
[0] = 0x10101010;
13572 digest
[1] = 0x10101010;
13573 digest
[2] = 0x10101010;
13574 digest
[3] = 0x10101010;
13576 return (PARSER_OK
);
13579 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13581 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13583 u32
*digest
= (u32
*) hash_buf
->digest
;
13585 salt_t
*salt
= hash_buf
->salt
;
13587 char *hashbuf_pos
= input_buf
;
13589 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13591 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13593 uint hash_len
= iterations_pos
- hashbuf_pos
;
13595 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13599 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13601 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13603 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13607 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13609 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13611 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13613 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13615 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13617 salt
->salt_len
= salt_len
;
13619 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13621 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13622 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13623 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13624 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13626 return (PARSER_OK
);
13629 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13631 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13633 u32
*digest
= (u32
*) hash_buf
->digest
;
13635 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13636 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13637 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13638 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13639 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13640 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13641 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13642 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13644 digest
[0] = byte_swap_32 (digest
[0]);
13645 digest
[1] = byte_swap_32 (digest
[1]);
13646 digest
[2] = byte_swap_32 (digest
[2]);
13647 digest
[3] = byte_swap_32 (digest
[3]);
13648 digest
[4] = byte_swap_32 (digest
[4]);
13649 digest
[5] = byte_swap_32 (digest
[5]);
13650 digest
[6] = byte_swap_32 (digest
[6]);
13651 digest
[7] = byte_swap_32 (digest
[7]);
13653 return (PARSER_OK
);
13656 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13658 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13660 u32
*digest
= (u32
*) hash_buf
->digest
;
13662 salt_t
*salt
= hash_buf
->salt
;
13664 char *salt_pos
= input_buf
+ 3;
13666 uint iterations_len
= 0;
13668 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13672 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13674 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13675 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13679 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13683 iterations_len
+= 8;
13687 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13690 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13692 char *hash_pos
= strchr (salt_pos
, '$');
13694 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13696 uint salt_len
= hash_pos
- salt_pos
;
13698 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13700 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13702 salt
->salt_len
= salt_len
;
13706 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13708 return (PARSER_OK
);
13711 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13713 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13715 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13717 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13719 u64
*digest
= (u64
*) hash_buf
->digest
;
13721 salt_t
*salt
= hash_buf
->salt
;
13723 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13725 char *iter_pos
= input_buf
+ 4;
13727 char *salt_pos
= strchr (iter_pos
, '$');
13729 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13733 char *hash_pos
= strchr (salt_pos
, '$');
13735 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13737 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13741 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13742 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13743 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13744 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13745 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13746 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13747 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13748 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13750 uint salt_len
= hash_pos
- salt_pos
- 1;
13752 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13754 salt
->salt_len
= salt_len
/ 2;
13756 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13757 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13758 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13759 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13760 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13761 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13762 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13763 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13765 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13766 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13767 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13768 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13769 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13770 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13771 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13772 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13773 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13774 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13776 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13778 salt
->salt_iter
= atoi (iter_pos
) - 1;
13780 return (PARSER_OK
);
13783 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13785 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13787 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13789 u32
*digest
= (u32
*) hash_buf
->digest
;
13791 salt_t
*salt
= hash_buf
->salt
;
13793 char *salt_pos
= input_buf
+ 14;
13795 char *hash_pos
= strchr (salt_pos
, '*');
13797 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13801 uint salt_len
= hash_pos
- salt_pos
- 1;
13803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13805 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13807 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13809 salt
->salt_len
= salt_len
;
13811 u8 tmp_buf
[100] = { 0 };
13813 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13815 memcpy (digest
, tmp_buf
, 32);
13817 digest
[0] = byte_swap_32 (digest
[0]);
13818 digest
[1] = byte_swap_32 (digest
[1]);
13819 digest
[2] = byte_swap_32 (digest
[2]);
13820 digest
[3] = byte_swap_32 (digest
[3]);
13821 digest
[4] = byte_swap_32 (digest
[4]);
13822 digest
[5] = byte_swap_32 (digest
[5]);
13823 digest
[6] = byte_swap_32 (digest
[6]);
13824 digest
[7] = byte_swap_32 (digest
[7]);
13826 digest
[0] -= SHA256M_A
;
13827 digest
[1] -= SHA256M_B
;
13828 digest
[2] -= SHA256M_C
;
13829 digest
[3] -= SHA256M_D
;
13830 digest
[4] -= SHA256M_E
;
13831 digest
[5] -= SHA256M_F
;
13832 digest
[6] -= SHA256M_G
;
13833 digest
[7] -= SHA256M_H
;
13835 return (PARSER_OK
);
13838 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13840 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13842 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13844 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13846 u64
*digest
= (u64
*) hash_buf
->digest
;
13848 salt_t
*salt
= hash_buf
->salt
;
13850 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13852 char *iter_pos
= input_buf
+ 19;
13854 char *salt_pos
= strchr (iter_pos
, '.');
13856 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13860 char *hash_pos
= strchr (salt_pos
, '.');
13862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13864 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13868 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13869 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13870 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13871 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13872 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13873 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13874 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13875 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13877 uint salt_len
= hash_pos
- salt_pos
- 1;
13881 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13885 for (i
= 0; i
< salt_len
; i
++)
13887 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13890 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13891 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13893 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13895 salt
->salt_len
= salt_len
;
13897 salt
->salt_iter
= atoi (iter_pos
) - 1;
13899 return (PARSER_OK
);
13902 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13904 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13906 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13908 u64
*digest
= (u64
*) hash_buf
->digest
;
13910 salt_t
*salt
= hash_buf
->salt
;
13912 u8 tmp_buf
[120] = { 0 };
13914 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13916 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13918 memcpy (digest
, tmp_buf
, 64);
13920 digest
[0] = byte_swap_64 (digest
[0]);
13921 digest
[1] = byte_swap_64 (digest
[1]);
13922 digest
[2] = byte_swap_64 (digest
[2]);
13923 digest
[3] = byte_swap_64 (digest
[3]);
13924 digest
[4] = byte_swap_64 (digest
[4]);
13925 digest
[5] = byte_swap_64 (digest
[5]);
13926 digest
[6] = byte_swap_64 (digest
[6]);
13927 digest
[7] = byte_swap_64 (digest
[7]);
13929 digest
[0] -= SHA512M_A
;
13930 digest
[1] -= SHA512M_B
;
13931 digest
[2] -= SHA512M_C
;
13932 digest
[3] -= SHA512M_D
;
13933 digest
[4] -= SHA512M_E
;
13934 digest
[5] -= SHA512M_F
;
13935 digest
[6] -= SHA512M_G
;
13936 digest
[7] -= SHA512M_H
;
13938 int salt_len
= tmp_len
- 64;
13940 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13942 salt
->salt_len
= salt_len
;
13944 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13946 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13948 char *ptr
= (char *) salt
->salt_buf
;
13950 ptr
[salt
->salt_len
] = 0x80;
13953 return (PARSER_OK
);
13956 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13958 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13960 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13964 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13967 u32
*digest
= (u32
*) hash_buf
->digest
;
13969 salt_t
*salt
= hash_buf
->salt
;
13971 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13972 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13973 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13974 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13976 digest
[0] = byte_swap_32 (digest
[0]);
13977 digest
[1] = byte_swap_32 (digest
[1]);
13978 digest
[2] = byte_swap_32 (digest
[2]);
13979 digest
[3] = byte_swap_32 (digest
[3]);
13981 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13983 uint salt_len
= input_len
- 32 - 1;
13985 char *salt_buf
= input_buf
+ 32 + 1;
13987 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13989 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13991 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13993 salt
->salt_len
= salt_len
;
13995 return (PARSER_OK
);
13998 int hmacsha1_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_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14006 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) 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]);
14017 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14019 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14021 uint salt_len
= input_len
- 40 - 1;
14023 char *salt_buf
= input_buf
+ 40 + 1;
14025 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14027 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14029 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14031 salt
->salt_len
= salt_len
;
14033 return (PARSER_OK
);
14036 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14038 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14040 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14044 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14047 u32
*digest
= (u32
*) hash_buf
->digest
;
14049 salt_t
*salt
= hash_buf
->salt
;
14051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14055 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14056 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14057 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14058 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14060 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14062 uint salt_len
= input_len
- 64 - 1;
14064 char *salt_buf
= input_buf
+ 64 + 1;
14066 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14070 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14072 salt
->salt_len
= salt_len
;
14074 return (PARSER_OK
);
14077 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14079 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14081 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14085 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14088 u64
*digest
= (u64
*) hash_buf
->digest
;
14090 salt_t
*salt
= hash_buf
->salt
;
14092 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14093 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14094 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14095 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14096 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14097 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14098 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14099 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14101 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14103 uint salt_len
= input_len
- 128 - 1;
14105 char *salt_buf
= input_buf
+ 128 + 1;
14107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14113 salt
->salt_len
= salt_len
;
14115 return (PARSER_OK
);
14118 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14120 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14122 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14124 u32
*digest
= (u32
*) hash_buf
->digest
;
14126 salt_t
*salt
= hash_buf
->salt
;
14128 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14134 char *user_pos
= input_buf
+ 10 + 1;
14136 char *realm_pos
= strchr (user_pos
, '$');
14138 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14140 uint user_len
= realm_pos
- user_pos
;
14142 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14146 char *salt_pos
= strchr (realm_pos
, '$');
14148 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14150 uint realm_len
= salt_pos
- realm_pos
;
14152 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14156 char *data_pos
= strchr (salt_pos
, '$');
14158 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14160 uint salt_len
= data_pos
- salt_pos
;
14162 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14166 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14168 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14174 memcpy (krb5pa
->user
, user_pos
, user_len
);
14175 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14176 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14178 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14180 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14182 const char p0
= data_pos
[i
+ 0];
14183 const char p1
= data_pos
[i
+ 1];
14185 *timestamp_ptr
++ = hex_convert (p1
) << 0
14186 | hex_convert (p0
) << 4;
14189 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14191 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14193 const char p0
= data_pos
[i
+ 0];
14194 const char p1
= data_pos
[i
+ 1];
14196 *checksum_ptr
++ = hex_convert (p1
) << 0
14197 | hex_convert (p0
) << 4;
14201 * copy some data to generic buffers to make sorting happy
14204 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14205 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14206 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14207 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14208 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14209 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14210 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14211 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14212 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14214 salt
->salt_len
= 36;
14216 digest
[0] = krb5pa
->checksum
[0];
14217 digest
[1] = krb5pa
->checksum
[1];
14218 digest
[2] = krb5pa
->checksum
[2];
14219 digest
[3] = krb5pa
->checksum
[3];
14221 return (PARSER_OK
);
14224 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14226 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14228 u32
*digest
= (u32
*) hash_buf
->digest
;
14230 salt_t
*salt
= hash_buf
->salt
;
14236 char *salt_pos
= input_buf
;
14238 char *hash_pos
= strchr (salt_pos
, '$');
14240 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14242 uint salt_len
= hash_pos
- salt_pos
;
14244 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14248 uint hash_len
= input_len
- 1 - salt_len
;
14250 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14258 for (uint i
= 0; i
< salt_len
; i
++)
14260 if (salt_pos
[i
] == ' ') continue;
14265 // SAP user names cannot be longer than 12 characters
14266 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14268 // SAP user name cannot start with ! or ?
14269 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14275 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14277 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14279 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14281 salt
->salt_len
= salt_len
;
14283 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14284 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14288 digest
[0] = byte_swap_32 (digest
[0]);
14289 digest
[1] = byte_swap_32 (digest
[1]);
14291 return (PARSER_OK
);
14294 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14296 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14298 u32
*digest
= (u32
*) hash_buf
->digest
;
14300 salt_t
*salt
= hash_buf
->salt
;
14306 char *salt_pos
= input_buf
;
14308 char *hash_pos
= strchr (salt_pos
, '$');
14310 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14312 uint salt_len
= hash_pos
- salt_pos
;
14314 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14318 uint hash_len
= input_len
- 1 - salt_len
;
14320 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14328 for (uint i
= 0; i
< salt_len
; i
++)
14330 if (salt_pos
[i
] == ' ') continue;
14335 // SAP user names cannot be longer than 12 characters
14336 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14337 // so far nobody complained so we stay with this because it helps in optimization
14338 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14340 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14342 // SAP user name cannot start with ! or ?
14343 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14349 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14351 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14353 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14355 salt
->salt_len
= salt_len
;
14357 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14358 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14359 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14360 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14361 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14363 return (PARSER_OK
);
14366 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14368 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14370 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14372 u64
*digest
= (u64
*) hash_buf
->digest
;
14374 salt_t
*salt
= hash_buf
->salt
;
14376 char *iter_pos
= input_buf
+ 3;
14378 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14380 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14382 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14384 salt
->salt_iter
= salt_iter
;
14386 char *salt_pos
= iter_pos
+ 1;
14390 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14392 salt
->salt_len
= salt_len
;
14394 char *hash_pos
= salt_pos
+ salt_len
;
14396 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14400 char *tmp
= (char *) salt
->salt_buf_pc
;
14402 tmp
[0] = hash_pos
[42];
14406 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14407 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14408 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14409 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14415 return (PARSER_OK
);
14418 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14420 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14422 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14424 u32
*digest
= (u32
*) hash_buf
->digest
;
14426 salt_t
*salt
= hash_buf
->salt
;
14428 char *salt_buf
= input_buf
+ 6;
14430 uint salt_len
= 16;
14432 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14434 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14436 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14438 salt
->salt_len
= salt_len
;
14440 char *hash_pos
= input_buf
+ 6 + 16;
14442 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14443 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14444 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14445 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14446 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14447 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14448 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14449 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14451 return (PARSER_OK
);
14454 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14456 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14458 u32
*digest
= (u32
*) hash_buf
->digest
;
14460 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14461 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14465 return (PARSER_OK
);
14468 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14470 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14472 u32
*digest
= (u32
*) hash_buf
->digest
;
14474 salt_t
*salt
= hash_buf
->salt
;
14476 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14478 char *saltbuf_pos
= input_buf
;
14480 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14482 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14484 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14486 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14487 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14489 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14493 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14495 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14497 char *salt_ptr
= (char *) saltbuf_pos
;
14498 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14503 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14505 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14508 rakp_ptr
[j
] = 0x80;
14510 rakp
->salt_len
= j
;
14512 for (i
= 0; i
< 64; i
++)
14514 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14517 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14518 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14519 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14520 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14521 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14522 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14523 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14524 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14526 salt
->salt_len
= 32; // muss min. 32 haben
14528 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14529 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14530 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14531 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14532 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14534 return (PARSER_OK
);
14537 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14539 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14541 u32
*digest
= (u32
*) hash_buf
->digest
;
14543 salt_t
*salt
= hash_buf
->salt
;
14545 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14547 char *salt_pos
= input_buf
+ 1;
14549 memcpy (salt
->salt_buf
, salt_pos
, 8);
14551 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14552 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14554 salt
->salt_len
= 8;
14556 char *hash_pos
= salt_pos
+ 8;
14558 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14559 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14560 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14561 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14562 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14564 digest
[0] -= SHA1M_A
;
14565 digest
[1] -= SHA1M_B
;
14566 digest
[2] -= SHA1M_C
;
14567 digest
[3] -= SHA1M_D
;
14568 digest
[4] -= SHA1M_E
;
14570 return (PARSER_OK
);
14573 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14575 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14577 u32
*digest
= (u32
*) hash_buf
->digest
;
14579 salt_t
*salt
= hash_buf
->salt
;
14581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14586 digest
[0] = byte_swap_32 (digest
[0]);
14587 digest
[1] = byte_swap_32 (digest
[1]);
14588 digest
[2] = byte_swap_32 (digest
[2]);
14589 digest
[3] = byte_swap_32 (digest
[3]);
14591 digest
[0] -= MD5M_A
;
14592 digest
[1] -= MD5M_B
;
14593 digest
[2] -= MD5M_C
;
14594 digest
[3] -= MD5M_D
;
14596 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14598 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14600 u32
*salt_buf
= salt
->salt_buf
;
14602 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14603 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14604 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14605 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14607 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14608 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14609 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14610 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14612 salt
->salt_len
= 16 + 1;
14614 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14616 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14618 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14620 return (PARSER_OK
);
14623 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14625 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14627 u32
*digest
= (u32
*) hash_buf
->digest
;
14629 salt_t
*salt
= hash_buf
->salt
;
14631 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14637 char *hashbuf_pos
= input_buf
;
14639 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14641 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14645 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14649 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14651 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14653 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14655 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14659 char *databuf_pos
= strchr (iteration_pos
, ':');
14661 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14663 const uint iteration_len
= databuf_pos
- iteration_pos
;
14665 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14666 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14668 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14670 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14671 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14677 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14678 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14679 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14680 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14681 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14682 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14683 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14684 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14688 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14690 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14692 const char p0
= saltbuf_pos
[i
+ 0];
14693 const char p1
= saltbuf_pos
[i
+ 1];
14695 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14696 | hex_convert (p0
) << 4;
14699 salt
->salt_buf
[4] = 0x01000000;
14700 salt
->salt_buf
[5] = 0x80;
14702 salt
->salt_len
= saltbuf_len
/ 2;
14706 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14710 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14712 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14714 const char p0
= databuf_pos
[i
+ 0];
14715 const char p1
= databuf_pos
[i
+ 1];
14717 *databuf_ptr
++ = hex_convert (p1
) << 0
14718 | hex_convert (p0
) << 4;
14721 *databuf_ptr
++ = 0x80;
14723 for (uint i
= 0; i
< 512; i
++)
14725 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14728 cloudkey
->data_len
= databuf_len
/ 2;
14730 return (PARSER_OK
);
14733 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14735 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14737 u32
*digest
= (u32
*) hash_buf
->digest
;
14739 salt_t
*salt
= hash_buf
->salt
;
14745 char *hashbuf_pos
= input_buf
;
14747 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14749 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14751 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14753 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14757 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14759 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14761 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14763 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14765 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14769 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14771 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14773 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14775 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14777 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14781 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14783 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14784 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14786 // ok, the plan for this algorithm is the following:
14787 // we have 2 salts here, the domain-name and a random salt
14788 // while both are used in the initial transformation,
14789 // only the random salt is used in the following iterations
14790 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14791 // and one that includes only the real salt (stored into salt_buf[]).
14792 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14794 u8 tmp_buf
[100] = { 0 };
14796 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14798 memcpy (digest
, tmp_buf
, 20);
14800 digest
[0] = byte_swap_32 (digest
[0]);
14801 digest
[1] = byte_swap_32 (digest
[1]);
14802 digest
[2] = byte_swap_32 (digest
[2]);
14803 digest
[3] = byte_swap_32 (digest
[3]);
14804 digest
[4] = byte_swap_32 (digest
[4]);
14808 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14810 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14812 char *len_ptr
= NULL
;
14814 for (uint i
= 0; i
< domainbuf_len
; i
++)
14816 if (salt_buf_pc_ptr
[i
] == '.')
14818 len_ptr
= &salt_buf_pc_ptr
[i
];
14828 salt
->salt_buf_pc
[7] = domainbuf_len
;
14832 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14834 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14836 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14838 salt
->salt_len
= salt_len
;
14842 salt
->salt_iter
= atoi (iteration_pos
);
14844 return (PARSER_OK
);
14847 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14849 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14851 u32
*digest
= (u32
*) hash_buf
->digest
;
14853 salt_t
*salt
= hash_buf
->salt
;
14855 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14856 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14857 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14858 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14859 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14861 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14863 uint salt_len
= input_len
- 40 - 1;
14865 char *salt_buf
= input_buf
+ 40 + 1;
14867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14869 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14871 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14873 salt
->salt_len
= salt_len
;
14875 return (PARSER_OK
);
14878 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14880 const u8 ascii_to_ebcdic
[] =
14882 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14883 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14884 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14885 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14886 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14887 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14888 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14889 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14890 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14891 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14892 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14893 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14894 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14895 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14896 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14897 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14900 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14902 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14904 u32
*digest
= (u32
*) hash_buf
->digest
;
14906 salt_t
*salt
= hash_buf
->salt
;
14908 char *salt_pos
= input_buf
+ 6 + 1;
14910 char *digest_pos
= strchr (salt_pos
, '*');
14912 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14914 uint salt_len
= digest_pos
- salt_pos
;
14916 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14918 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14920 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14924 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14925 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14927 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14929 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14931 salt
->salt_len
= salt_len
;
14933 for (uint i
= 0; i
< salt_len
; i
++)
14935 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14937 for (uint i
= salt_len
; i
< 8; i
++)
14939 salt_buf_pc_ptr
[i
] = 0x40;
14944 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14946 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14947 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14949 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14950 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14952 digest
[0] = byte_swap_32 (digest
[0]);
14953 digest
[1] = byte_swap_32 (digest
[1]);
14955 IP (digest
[0], digest
[1], tt
);
14957 digest
[0] = rotr32 (digest
[0], 29);
14958 digest
[1] = rotr32 (digest
[1], 29);
14962 return (PARSER_OK
);
14965 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14967 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14969 u32
*digest
= (u32
*) hash_buf
->digest
;
14971 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14972 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14973 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14974 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14976 digest
[0] = byte_swap_32 (digest
[0]);
14977 digest
[1] = byte_swap_32 (digest
[1]);
14978 digest
[2] = byte_swap_32 (digest
[2]);
14979 digest
[3] = byte_swap_32 (digest
[3]);
14981 return (PARSER_OK
);
14984 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14986 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14988 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14990 u32
*digest
= (u32
*) hash_buf
->digest
;
14992 salt_t
*salt
= hash_buf
->salt
;
14994 u8 tmp_buf
[120] = { 0 };
14996 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14998 tmp_buf
[3] += -4; // dont ask!
15000 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15002 salt
->salt_len
= 5;
15004 memcpy (digest
, tmp_buf
+ 5, 9);
15006 // yes, only 9 byte are needed to crack, but 10 to display
15008 salt
->salt_buf_pc
[7] = input_buf
[20];
15010 return (PARSER_OK
);
15013 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15015 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15017 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15019 u32
*digest
= (u32
*) hash_buf
->digest
;
15021 salt_t
*salt
= hash_buf
->salt
;
15023 u8 tmp_buf
[120] = { 0 };
15025 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15027 tmp_buf
[3] += -4; // dont ask!
15031 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15033 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)
15037 char tmp_iter_buf
[11] = { 0 };
15039 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15041 tmp_iter_buf
[10] = 0;
15043 salt
->salt_iter
= atoi (tmp_iter_buf
);
15045 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15047 return (PARSER_SALT_ITERATION
);
15050 salt
->salt_iter
--; // first round in init
15052 // 2 additional bytes for display only
15054 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15055 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15059 memcpy (digest
, tmp_buf
+ 28, 8);
15061 digest
[0] = byte_swap_32 (digest
[0]);
15062 digest
[1] = byte_swap_32 (digest
[1]);
15066 return (PARSER_OK
);
15069 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15071 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15073 u32
*digest
= (u32
*) hash_buf
->digest
;
15075 salt_t
*salt
= hash_buf
->salt
;
15077 char *salt_buf_pos
= input_buf
;
15079 char *hash_buf_pos
= salt_buf_pos
+ 6;
15081 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15082 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15083 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15084 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15085 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15086 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15087 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15088 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15090 digest
[0] -= SHA256M_A
;
15091 digest
[1] -= SHA256M_B
;
15092 digest
[2] -= SHA256M_C
;
15093 digest
[3] -= SHA256M_D
;
15094 digest
[4] -= SHA256M_E
;
15095 digest
[5] -= SHA256M_F
;
15096 digest
[6] -= SHA256M_G
;
15097 digest
[7] -= SHA256M_H
;
15099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15101 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15103 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15105 salt
->salt_len
= salt_len
;
15107 return (PARSER_OK
);
15110 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15112 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15114 u32
*digest
= (u32
*) hash_buf
->digest
;
15116 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15118 salt_t
*salt
= hash_buf
->salt
;
15120 char *salt_buf
= input_buf
+ 6;
15122 char *digest_buf
= strchr (salt_buf
, '$');
15124 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15126 uint salt_len
= digest_buf
- salt_buf
;
15128 digest_buf
++; // skip the '$' symbol
15130 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15132 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15134 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15136 salt
->salt_len
= salt_len
;
15138 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15139 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15140 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15141 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15143 digest
[0] = byte_swap_32 (digest
[0]);
15144 digest
[1] = byte_swap_32 (digest
[1]);
15145 digest
[2] = byte_swap_32 (digest
[2]);
15146 digest
[3] = byte_swap_32 (digest
[3]);
15148 digest
[0] -= MD5M_A
;
15149 digest
[1] -= MD5M_B
;
15150 digest
[2] -= MD5M_C
;
15151 digest
[3] -= MD5M_D
;
15153 return (PARSER_OK
);
15156 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15158 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15160 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15162 u32
*digest
= (u32
*) hash_buf
->digest
;
15164 salt_t
*salt
= hash_buf
->salt
;
15166 char *salt_buf
= input_buf
+ 3;
15168 char *digest_buf
= strchr (salt_buf
, '$');
15170 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15172 uint salt_len
= digest_buf
- salt_buf
;
15174 digest_buf
++; // skip the '$' symbol
15176 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15178 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15180 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15182 salt_buf_ptr
[salt_len
] = 0x2d;
15184 salt
->salt_len
= salt_len
+ 1;
15186 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15187 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15188 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15189 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15191 digest
[0] = byte_swap_32 (digest
[0]);
15192 digest
[1] = byte_swap_32 (digest
[1]);
15193 digest
[2] = byte_swap_32 (digest
[2]);
15194 digest
[3] = byte_swap_32 (digest
[3]);
15196 digest
[0] -= MD5M_A
;
15197 digest
[1] -= MD5M_B
;
15198 digest
[2] -= MD5M_C
;
15199 digest
[3] -= MD5M_D
;
15201 return (PARSER_OK
);
15204 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15206 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15208 u32
*digest
= (u32
*) hash_buf
->digest
;
15210 salt_t
*salt
= hash_buf
->salt
;
15212 u8 tmp_buf
[100] = { 0 };
15214 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15216 memcpy (digest
, tmp_buf
, 20);
15218 digest
[0] = byte_swap_32 (digest
[0]);
15219 digest
[1] = byte_swap_32 (digest
[1]);
15220 digest
[2] = byte_swap_32 (digest
[2]);
15221 digest
[3] = byte_swap_32 (digest
[3]);
15222 digest
[4] = byte_swap_32 (digest
[4]);
15224 digest
[0] -= SHA1M_A
;
15225 digest
[1] -= SHA1M_B
;
15226 digest
[2] -= SHA1M_C
;
15227 digest
[3] -= SHA1M_D
;
15228 digest
[4] -= SHA1M_E
;
15230 salt
->salt_buf
[0] = 0x80;
15232 salt
->salt_len
= 0;
15234 return (PARSER_OK
);
15237 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15239 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15241 u32
*digest
= (u32
*) hash_buf
->digest
;
15243 salt_t
*salt
= hash_buf
->salt
;
15245 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15246 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15247 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15248 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15250 digest
[0] = byte_swap_32 (digest
[0]);
15251 digest
[1] = byte_swap_32 (digest
[1]);
15252 digest
[2] = byte_swap_32 (digest
[2]);
15253 digest
[3] = byte_swap_32 (digest
[3]);
15255 digest
[0] -= MD5M_A
;
15256 digest
[1] -= MD5M_B
;
15257 digest
[2] -= MD5M_C
;
15258 digest
[3] -= MD5M_D
;
15260 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15262 uint salt_len
= input_len
- 32 - 1;
15264 char *salt_buf
= input_buf
+ 32 + 1;
15266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15268 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15270 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15273 * add static "salt" part
15276 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15280 salt
->salt_len
= salt_len
;
15282 return (PARSER_OK
);
15285 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15287 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15289 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15291 u32
*digest
= (u32
*) hash_buf
->digest
;
15293 salt_t
*salt
= hash_buf
->salt
;
15295 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15301 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15303 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15305 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15309 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15313 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15315 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15317 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15319 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15323 char *keybuf_pos
= strchr (keylen_pos
, '$');
15325 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15327 uint keylen_len
= keybuf_pos
- keylen_pos
;
15329 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15333 char *databuf_pos
= strchr (keybuf_pos
, '$');
15335 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15337 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15339 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15343 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15345 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15351 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15352 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15353 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15354 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15356 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15357 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15358 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15359 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15361 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15362 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15363 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15364 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15366 salt
->salt_len
= 16;
15367 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15369 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15371 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15374 return (PARSER_OK
);
15377 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15379 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15381 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15383 u32
*digest
= (u32
*) hash_buf
->digest
;
15385 salt_t
*salt
= hash_buf
->salt
;
15391 // first is the N salt parameter
15393 char *N_pos
= input_buf
+ 6;
15395 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15399 salt
->scrypt_N
= atoi (N_pos
);
15403 char *r_pos
= strchr (N_pos
, ':');
15405 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15409 salt
->scrypt_r
= atoi (r_pos
);
15413 char *p_pos
= strchr (r_pos
, ':');
15415 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15419 salt
->scrypt_p
= atoi (p_pos
);
15423 char *saltbuf_pos
= strchr (p_pos
, ':');
15425 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15429 char *hash_pos
= strchr (saltbuf_pos
, ':');
15431 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15437 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15439 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15441 u8 tmp_buf
[33] = { 0 };
15443 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15445 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15447 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15449 salt
->salt_len
= tmp_len
;
15450 salt
->salt_iter
= 1;
15452 // digest - base64 decode
15454 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15456 tmp_len
= input_len
- (hash_pos
- input_buf
);
15458 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15460 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15462 memcpy (digest
, tmp_buf
, 32);
15464 return (PARSER_OK
);
15467 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15469 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15471 u32
*digest
= (u32
*) hash_buf
->digest
;
15473 salt_t
*salt
= hash_buf
->salt
;
15479 char decrypted
[76] = { 0 }; // iv + hash
15481 juniper_decrypt_hash (input_buf
, decrypted
);
15483 char *md5crypt_hash
= decrypted
+ 12;
15485 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15487 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15489 char *salt_pos
= md5crypt_hash
+ 3;
15491 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15493 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15495 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15499 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15501 return (PARSER_OK
);
15504 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15506 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15508 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15510 u32
*digest
= (u32
*) hash_buf
->digest
;
15512 salt_t
*salt
= hash_buf
->salt
;
15514 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15520 // first is *raw* salt
15522 char *salt_pos
= input_buf
+ 3;
15524 char *hash_pos
= strchr (salt_pos
, '$');
15526 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 uint salt_len
= hash_pos
- salt_pos
;
15530 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15534 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15536 memcpy (salt_buf_ptr
, salt_pos
, 14);
15538 salt_buf_ptr
[17] = 0x01;
15539 salt_buf_ptr
[18] = 0x80;
15541 // add some stuff to normal salt to make sorted happy
15543 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15544 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15545 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15546 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15548 salt
->salt_len
= salt_len
;
15549 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15551 // base64 decode hash
15553 u8 tmp_buf
[100] = { 0 };
15555 uint hash_len
= input_len
- 3 - salt_len
- 1;
15557 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15559 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15561 memcpy (digest
, tmp_buf
, 32);
15563 digest
[0] = byte_swap_32 (digest
[0]);
15564 digest
[1] = byte_swap_32 (digest
[1]);
15565 digest
[2] = byte_swap_32 (digest
[2]);
15566 digest
[3] = byte_swap_32 (digest
[3]);
15567 digest
[4] = byte_swap_32 (digest
[4]);
15568 digest
[5] = byte_swap_32 (digest
[5]);
15569 digest
[6] = byte_swap_32 (digest
[6]);
15570 digest
[7] = byte_swap_32 (digest
[7]);
15572 return (PARSER_OK
);
15575 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15577 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15579 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15581 u32
*digest
= (u32
*) hash_buf
->digest
;
15583 salt_t
*salt
= hash_buf
->salt
;
15589 // first is *raw* salt
15591 char *salt_pos
= input_buf
+ 3;
15593 char *hash_pos
= strchr (salt_pos
, '$');
15595 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15597 uint salt_len
= hash_pos
- salt_pos
;
15599 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15601 salt
->salt_len
= salt_len
;
15604 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15606 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15607 salt_buf_ptr
[salt_len
] = 0;
15609 // base64 decode hash
15611 u8 tmp_buf
[100] = { 0 };
15613 uint hash_len
= input_len
- 3 - salt_len
- 1;
15615 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15617 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15619 memcpy (digest
, tmp_buf
, 32);
15622 salt
->scrypt_N
= 16384;
15623 salt
->scrypt_r
= 1;
15624 salt
->scrypt_p
= 1;
15625 salt
->salt_iter
= 1;
15627 return (PARSER_OK
);
15630 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15632 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15634 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15636 u32
*digest
= (u32
*) hash_buf
->digest
;
15638 salt_t
*salt
= hash_buf
->salt
;
15640 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15646 char *version_pos
= input_buf
+ 8 + 1;
15648 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15650 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15652 u32 version_len
= verifierHashSize_pos
- version_pos
;
15654 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15656 verifierHashSize_pos
++;
15658 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15660 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15662 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15664 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15668 char *saltSize_pos
= strchr (keySize_pos
, '*');
15670 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15672 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15674 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15678 char *osalt_pos
= strchr (saltSize_pos
, '*');
15680 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15682 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15684 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15688 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15690 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15692 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15694 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15696 encryptedVerifier_pos
++;
15698 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15700 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15702 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15704 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15706 encryptedVerifierHash_pos
++;
15708 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;
15710 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15712 const uint version
= atoi (version_pos
);
15714 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15716 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15718 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15720 const uint keySize
= atoi (keySize_pos
);
15722 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15724 office2007
->keySize
= keySize
;
15726 const uint saltSize
= atoi (saltSize_pos
);
15728 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15734 salt
->salt_len
= 16;
15735 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15737 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15738 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15739 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15740 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15746 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15747 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15748 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15749 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15751 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15752 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15753 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15754 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15755 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15761 digest
[0] = office2007
->encryptedVerifierHash
[0];
15762 digest
[1] = office2007
->encryptedVerifierHash
[1];
15763 digest
[2] = office2007
->encryptedVerifierHash
[2];
15764 digest
[3] = office2007
->encryptedVerifierHash
[3];
15766 return (PARSER_OK
);
15769 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15771 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15773 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15775 u32
*digest
= (u32
*) hash_buf
->digest
;
15777 salt_t
*salt
= hash_buf
->salt
;
15779 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15785 char *version_pos
= input_buf
+ 8 + 1;
15787 char *spinCount_pos
= strchr (version_pos
, '*');
15789 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15791 u32 version_len
= spinCount_pos
- version_pos
;
15793 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15797 char *keySize_pos
= strchr (spinCount_pos
, '*');
15799 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15801 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15803 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15807 char *saltSize_pos
= strchr (keySize_pos
, '*');
15809 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15811 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15813 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15817 char *osalt_pos
= strchr (saltSize_pos
, '*');
15819 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15821 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15823 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15827 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15829 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15831 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15833 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15835 encryptedVerifier_pos
++;
15837 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15839 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15841 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15843 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15845 encryptedVerifierHash_pos
++;
15847 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;
15849 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15851 const uint version
= atoi (version_pos
);
15853 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15855 const uint spinCount
= atoi (spinCount_pos
);
15857 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15859 const uint keySize
= atoi (keySize_pos
);
15861 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15863 const uint saltSize
= atoi (saltSize_pos
);
15865 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15871 salt
->salt_len
= 16;
15872 salt
->salt_iter
= spinCount
;
15874 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15875 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15876 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15877 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15883 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15884 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15885 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15886 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15888 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15889 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15890 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15891 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15892 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15893 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15894 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15895 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15901 digest
[0] = office2010
->encryptedVerifierHash
[0];
15902 digest
[1] = office2010
->encryptedVerifierHash
[1];
15903 digest
[2] = office2010
->encryptedVerifierHash
[2];
15904 digest
[3] = office2010
->encryptedVerifierHash
[3];
15906 return (PARSER_OK
);
15909 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15911 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15913 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15915 u32
*digest
= (u32
*) hash_buf
->digest
;
15917 salt_t
*salt
= hash_buf
->salt
;
15919 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15925 char *version_pos
= input_buf
+ 8 + 1;
15927 char *spinCount_pos
= strchr (version_pos
, '*');
15929 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15931 u32 version_len
= spinCount_pos
- version_pos
;
15933 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15937 char *keySize_pos
= strchr (spinCount_pos
, '*');
15939 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15941 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15943 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15947 char *saltSize_pos
= strchr (keySize_pos
, '*');
15949 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15951 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15953 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15957 char *osalt_pos
= strchr (saltSize_pos
, '*');
15959 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15961 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15963 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15967 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15969 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15971 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15973 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15975 encryptedVerifier_pos
++;
15977 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15979 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15981 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15983 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15985 encryptedVerifierHash_pos
++;
15987 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;
15989 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15991 const uint version
= atoi (version_pos
);
15993 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15995 const uint spinCount
= atoi (spinCount_pos
);
15997 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15999 const uint keySize
= atoi (keySize_pos
);
16001 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16003 const uint saltSize
= atoi (saltSize_pos
);
16005 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16011 salt
->salt_len
= 16;
16012 salt
->salt_iter
= spinCount
;
16014 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16015 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16016 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16017 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16023 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16024 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16025 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16026 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16028 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16029 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16030 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16031 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16032 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16033 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16034 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16035 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16041 digest
[0] = office2013
->encryptedVerifierHash
[0];
16042 digest
[1] = office2013
->encryptedVerifierHash
[1];
16043 digest
[2] = office2013
->encryptedVerifierHash
[2];
16044 digest
[3] = office2013
->encryptedVerifierHash
[3];
16046 return (PARSER_OK
);
16049 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16051 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16053 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16055 u32
*digest
= (u32
*) hash_buf
->digest
;
16057 salt_t
*salt
= hash_buf
->salt
;
16059 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16065 char *version_pos
= input_buf
+ 11;
16067 char *osalt_pos
= strchr (version_pos
, '*');
16069 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16071 u32 version_len
= osalt_pos
- version_pos
;
16073 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16077 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16079 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16081 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16083 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16085 encryptedVerifier_pos
++;
16087 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16089 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16091 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16093 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16095 encryptedVerifierHash_pos
++;
16097 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16099 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16101 const uint version
= *version_pos
- 0x30;
16103 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16109 oldoffice01
->version
= version
;
16111 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16112 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16113 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16114 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16116 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16117 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16118 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16119 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16121 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16122 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16123 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16124 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16126 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16127 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16128 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16129 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16135 salt
->salt_len
= 16;
16137 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16138 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16139 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16140 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16142 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16143 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16144 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16145 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16147 // this is a workaround as office produces multiple documents with the same salt
16149 salt
->salt_len
+= 32;
16151 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16152 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16153 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16154 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16155 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16156 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16157 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16158 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16164 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16165 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16166 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16167 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16169 return (PARSER_OK
);
16172 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16174 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16177 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16179 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16181 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16183 u32
*digest
= (u32
*) hash_buf
->digest
;
16185 salt_t
*salt
= hash_buf
->salt
;
16187 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16193 char *version_pos
= input_buf
+ 11;
16195 char *osalt_pos
= strchr (version_pos
, '*');
16197 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16199 u32 version_len
= osalt_pos
- version_pos
;
16201 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16205 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16207 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16209 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16211 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16213 encryptedVerifier_pos
++;
16215 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16217 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16219 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16221 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16223 encryptedVerifierHash_pos
++;
16225 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16227 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16229 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16231 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16235 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16237 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16239 const uint version
= *version_pos
- 0x30;
16241 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16247 oldoffice01
->version
= version
;
16249 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16250 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16251 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16252 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16254 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16255 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16256 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16257 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16259 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16260 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16261 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16262 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16264 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16265 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16266 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16267 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16269 oldoffice01
->rc4key
[1] = 0;
16270 oldoffice01
->rc4key
[0] = 0;
16272 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16273 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16274 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16275 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16276 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16277 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16278 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16279 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16280 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16281 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16283 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16284 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16290 salt
->salt_len
= 16;
16292 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16293 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16294 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16295 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16297 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16298 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16299 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16300 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16302 // this is a workaround as office produces multiple documents with the same salt
16304 salt
->salt_len
+= 32;
16306 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16307 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16308 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16309 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16310 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16311 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16312 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16313 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16319 digest
[0] = oldoffice01
->rc4key
[0];
16320 digest
[1] = oldoffice01
->rc4key
[1];
16324 return (PARSER_OK
);
16327 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16329 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16331 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16333 u32
*digest
= (u32
*) hash_buf
->digest
;
16335 salt_t
*salt
= hash_buf
->salt
;
16337 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16343 char *version_pos
= input_buf
+ 11;
16345 char *osalt_pos
= strchr (version_pos
, '*');
16347 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16349 u32 version_len
= osalt_pos
- version_pos
;
16351 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16355 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16357 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16359 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16361 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16363 encryptedVerifier_pos
++;
16365 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16367 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16369 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16371 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16373 encryptedVerifierHash_pos
++;
16375 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16377 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16379 const uint version
= *version_pos
- 0x30;
16381 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16387 oldoffice34
->version
= version
;
16389 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16390 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16391 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16392 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16394 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16395 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16396 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16397 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16399 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16400 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16401 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16402 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16403 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16405 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16406 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16407 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16408 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16409 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16415 salt
->salt_len
= 16;
16417 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16418 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16419 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16420 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16422 // this is a workaround as office produces multiple documents with the same salt
16424 salt
->salt_len
+= 32;
16426 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16427 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16428 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16429 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16430 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16431 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16432 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16433 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16439 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16440 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16441 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16442 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16444 return (PARSER_OK
);
16447 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16449 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16451 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16454 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16456 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16458 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16460 u32
*digest
= (u32
*) hash_buf
->digest
;
16462 salt_t
*salt
= hash_buf
->salt
;
16464 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16470 char *version_pos
= input_buf
+ 11;
16472 char *osalt_pos
= strchr (version_pos
, '*');
16474 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16476 u32 version_len
= osalt_pos
- version_pos
;
16478 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16482 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16484 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16486 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16488 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16490 encryptedVerifier_pos
++;
16492 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16494 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16496 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16498 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16500 encryptedVerifierHash_pos
++;
16502 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16504 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16506 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16508 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16512 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16514 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16516 const uint version
= *version_pos
- 0x30;
16518 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16524 oldoffice34
->version
= version
;
16526 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16527 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16528 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16529 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16531 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16532 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16533 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16534 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16536 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16537 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16538 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16539 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16540 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16542 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16543 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16544 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16545 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16546 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16548 oldoffice34
->rc4key
[1] = 0;
16549 oldoffice34
->rc4key
[0] = 0;
16551 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16552 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16553 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16554 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16555 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16556 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16557 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16558 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16559 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16560 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16562 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16563 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16569 salt
->salt_len
= 16;
16571 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16572 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16573 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16574 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16576 // this is a workaround as office produces multiple documents with the same salt
16578 salt
->salt_len
+= 32;
16580 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16581 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16582 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16583 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16584 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16585 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16586 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16587 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16593 digest
[0] = oldoffice34
->rc4key
[0];
16594 digest
[1] = oldoffice34
->rc4key
[1];
16598 return (PARSER_OK
);
16601 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16603 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16605 u32
*digest
= (u32
*) hash_buf
->digest
;
16607 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16608 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16609 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16610 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16612 digest
[0] = byte_swap_32 (digest
[0]);
16613 digest
[1] = byte_swap_32 (digest
[1]);
16614 digest
[2] = byte_swap_32 (digest
[2]);
16615 digest
[3] = byte_swap_32 (digest
[3]);
16617 return (PARSER_OK
);
16620 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16622 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16624 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16626 u32
*digest
= (u32
*) hash_buf
->digest
;
16628 salt_t
*salt
= hash_buf
->salt
;
16630 char *signature_pos
= input_buf
;
16632 char *salt_pos
= strchr (signature_pos
, '$');
16634 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16636 u32 signature_len
= salt_pos
- signature_pos
;
16638 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16642 char *hash_pos
= strchr (salt_pos
, '$');
16644 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16646 u32 salt_len
= hash_pos
- salt_pos
;
16648 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16652 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16654 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16656 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16657 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16658 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16659 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16660 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16662 digest
[0] -= SHA1M_A
;
16663 digest
[1] -= SHA1M_B
;
16664 digest
[2] -= SHA1M_C
;
16665 digest
[3] -= SHA1M_D
;
16666 digest
[4] -= SHA1M_E
;
16668 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16670 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16672 salt
->salt_len
= salt_len
;
16674 return (PARSER_OK
);
16677 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16679 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16681 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16683 u32
*digest
= (u32
*) hash_buf
->digest
;
16685 salt_t
*salt
= hash_buf
->salt
;
16687 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16693 char *iter_pos
= input_buf
+ 14;
16695 const int iter
= atoi (iter_pos
);
16697 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16699 salt
->salt_iter
= iter
- 1;
16701 char *salt_pos
= strchr (iter_pos
, '$');
16703 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16707 char *hash_pos
= strchr (salt_pos
, '$');
16709 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16711 const uint salt_len
= hash_pos
- salt_pos
;
16715 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16717 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16719 salt
->salt_len
= salt_len
;
16721 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16722 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16724 // add some stuff to normal salt to make sorted happy
16726 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16727 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16728 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16729 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16730 salt
->salt_buf
[4] = salt
->salt_iter
;
16732 // base64 decode hash
16734 u8 tmp_buf
[100] = { 0 };
16736 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16738 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16740 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16742 memcpy (digest
, tmp_buf
, 32);
16744 digest
[0] = byte_swap_32 (digest
[0]);
16745 digest
[1] = byte_swap_32 (digest
[1]);
16746 digest
[2] = byte_swap_32 (digest
[2]);
16747 digest
[3] = byte_swap_32 (digest
[3]);
16748 digest
[4] = byte_swap_32 (digest
[4]);
16749 digest
[5] = byte_swap_32 (digest
[5]);
16750 digest
[6] = byte_swap_32 (digest
[6]);
16751 digest
[7] = byte_swap_32 (digest
[7]);
16753 return (PARSER_OK
);
16756 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16758 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16760 u32
*digest
= (u32
*) hash_buf
->digest
;
16762 salt_t
*salt
= hash_buf
->salt
;
16764 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16765 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16769 digest
[0] = byte_swap_32 (digest
[0]);
16770 digest
[1] = byte_swap_32 (digest
[1]);
16772 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16773 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16774 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16776 char iter_c
= input_buf
[17];
16777 char iter_d
= input_buf
[19];
16779 // atm only defaults, let's see if there's more request
16780 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16781 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16783 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16785 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16786 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16787 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16788 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16790 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16791 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16792 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16793 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16795 salt
->salt_len
= 16;
16797 return (PARSER_OK
);
16800 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16802 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16804 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16806 u32
*digest
= (u32
*) hash_buf
->digest
;
16808 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16810 salt_t
*salt
= hash_buf
->salt
;
16812 char *salt_pos
= input_buf
+ 10;
16814 char *hash_pos
= strchr (salt_pos
, '$');
16816 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16818 uint salt_len
= hash_pos
- salt_pos
;
16822 uint hash_len
= input_len
- 10 - salt_len
- 1;
16824 // base64 decode salt
16826 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16828 u8 tmp_buf
[100] = { 0 };
16830 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16832 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16834 tmp_buf
[salt_len
] = 0x80;
16836 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16838 salt
->salt_len
= salt_len
;
16840 // base64 decode hash
16842 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16844 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16846 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16848 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16850 uint user_len
= hash_len
- 32;
16852 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16854 user_len
--; // skip the trailing space
16856 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16857 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16858 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16859 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16861 digest
[0] = byte_swap_32 (digest
[0]);
16862 digest
[1] = byte_swap_32 (digest
[1]);
16863 digest
[2] = byte_swap_32 (digest
[2]);
16864 digest
[3] = byte_swap_32 (digest
[3]);
16866 // store username for host only (output hash if cracked)
16868 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16869 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16871 return (PARSER_OK
);
16874 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16876 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16878 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16880 u32
*digest
= (u32
*) hash_buf
->digest
;
16882 salt_t
*salt
= hash_buf
->salt
;
16884 char *iter_pos
= input_buf
+ 10;
16886 u32 iter
= atoi (iter_pos
);
16890 return (PARSER_SALT_ITERATION
);
16893 iter
--; // first iteration is special
16895 salt
->salt_iter
= iter
;
16897 char *base64_pos
= strchr (iter_pos
, '}');
16899 if (base64_pos
== NULL
)
16901 return (PARSER_SIGNATURE_UNMATCHED
);
16906 // base64 decode salt
16908 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16910 u8 tmp_buf
[100] = { 0 };
16912 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16914 if (decoded_len
< 24)
16916 return (PARSER_SALT_LENGTH
);
16921 uint salt_len
= decoded_len
- 20;
16923 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16924 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16926 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16928 salt
->salt_len
= salt_len
;
16932 u32
*digest_ptr
= (u32
*) tmp_buf
;
16934 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16935 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16936 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16937 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16938 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16940 return (PARSER_OK
);
16943 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16945 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16947 u32
*digest
= (u32
*) hash_buf
->digest
;
16949 salt_t
*salt
= hash_buf
->salt
;
16951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16953 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16954 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16955 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16957 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16959 uint salt_len
= input_len
- 40 - 1;
16961 char *salt_buf
= input_buf
+ 40 + 1;
16963 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16965 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16967 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16969 salt
->salt_len
= salt_len
;
16971 return (PARSER_OK
);
16974 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16976 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16978 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16980 u32
*digest
= (u32
*) hash_buf
->digest
;
16982 salt_t
*salt
= hash_buf
->salt
;
16984 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16990 char *V_pos
= input_buf
+ 5;
16992 char *R_pos
= strchr (V_pos
, '*');
16994 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16996 u32 V_len
= R_pos
- V_pos
;
17000 char *bits_pos
= strchr (R_pos
, '*');
17002 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17004 u32 R_len
= bits_pos
- R_pos
;
17008 char *P_pos
= strchr (bits_pos
, '*');
17010 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17012 u32 bits_len
= P_pos
- bits_pos
;
17016 char *enc_md_pos
= strchr (P_pos
, '*');
17018 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17020 u32 P_len
= enc_md_pos
- P_pos
;
17024 char *id_len_pos
= strchr (enc_md_pos
, '*');
17026 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17028 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17032 char *id_buf_pos
= strchr (id_len_pos
, '*');
17034 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17036 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17040 char *u_len_pos
= strchr (id_buf_pos
, '*');
17042 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17044 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17046 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17050 char *u_buf_pos
= strchr (u_len_pos
, '*');
17052 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17054 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17058 char *o_len_pos
= strchr (u_buf_pos
, '*');
17060 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17062 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17064 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17068 char *o_buf_pos
= strchr (o_len_pos
, '*');
17070 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17072 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17076 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;
17078 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17082 const int V
= atoi (V_pos
);
17083 const int R
= atoi (R_pos
);
17084 const int P
= atoi (P_pos
);
17086 if (V
!= 1) return (PARSER_SALT_VALUE
);
17087 if (R
!= 2) return (PARSER_SALT_VALUE
);
17089 const int enc_md
= atoi (enc_md_pos
);
17091 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17093 const int id_len
= atoi (id_len_pos
);
17094 const int u_len
= atoi (u_len_pos
);
17095 const int o_len
= atoi (o_len_pos
);
17097 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17098 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17099 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17101 const int bits
= atoi (bits_pos
);
17103 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17105 // copy data to esalt
17111 pdf
->enc_md
= enc_md
;
17113 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17114 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17115 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17116 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17117 pdf
->id_len
= id_len
;
17119 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17120 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17121 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17122 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17123 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17124 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17125 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17126 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17127 pdf
->u_len
= u_len
;
17129 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17130 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17131 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17132 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17133 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17134 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17135 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17136 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17137 pdf
->o_len
= o_len
;
17139 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17140 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17141 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17142 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17144 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17145 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17146 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17147 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17148 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17149 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17150 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17151 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17153 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17154 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17155 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17156 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17157 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17158 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17159 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17160 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17162 // we use ID for salt, maybe needs to change, we will see...
17164 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17165 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17166 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17167 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17168 salt
->salt_len
= pdf
->id_len
;
17170 digest
[0] = pdf
->u_buf
[0];
17171 digest
[1] = pdf
->u_buf
[1];
17172 digest
[2] = pdf
->u_buf
[2];
17173 digest
[3] = pdf
->u_buf
[3];
17175 return (PARSER_OK
);
17178 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17180 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17183 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17185 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17187 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17189 u32
*digest
= (u32
*) hash_buf
->digest
;
17191 salt_t
*salt
= hash_buf
->salt
;
17193 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17199 char *V_pos
= input_buf
+ 5;
17201 char *R_pos
= strchr (V_pos
, '*');
17203 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17205 u32 V_len
= R_pos
- V_pos
;
17209 char *bits_pos
= strchr (R_pos
, '*');
17211 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17213 u32 R_len
= bits_pos
- R_pos
;
17217 char *P_pos
= strchr (bits_pos
, '*');
17219 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17221 u32 bits_len
= P_pos
- bits_pos
;
17225 char *enc_md_pos
= strchr (P_pos
, '*');
17227 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17229 u32 P_len
= enc_md_pos
- P_pos
;
17233 char *id_len_pos
= strchr (enc_md_pos
, '*');
17235 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17237 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17241 char *id_buf_pos
= strchr (id_len_pos
, '*');
17243 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17245 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17249 char *u_len_pos
= strchr (id_buf_pos
, '*');
17251 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17255 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17259 char *u_buf_pos
= strchr (u_len_pos
, '*');
17261 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17263 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17267 char *o_len_pos
= strchr (u_buf_pos
, '*');
17269 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17271 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17273 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17277 char *o_buf_pos
= strchr (o_len_pos
, '*');
17279 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17281 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17285 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17287 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17289 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17291 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17295 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;
17297 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17301 const int V
= atoi (V_pos
);
17302 const int R
= atoi (R_pos
);
17303 const int P
= atoi (P_pos
);
17305 if (V
!= 1) return (PARSER_SALT_VALUE
);
17306 if (R
!= 2) return (PARSER_SALT_VALUE
);
17308 const int enc_md
= atoi (enc_md_pos
);
17310 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17312 const int id_len
= atoi (id_len_pos
);
17313 const int u_len
= atoi (u_len_pos
);
17314 const int o_len
= atoi (o_len_pos
);
17316 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17317 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17318 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17320 const int bits
= atoi (bits_pos
);
17322 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17324 // copy data to esalt
17330 pdf
->enc_md
= enc_md
;
17332 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17333 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17334 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17335 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17336 pdf
->id_len
= id_len
;
17338 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17339 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17340 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17341 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17342 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17343 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17344 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17345 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17346 pdf
->u_len
= u_len
;
17348 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17349 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17350 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17351 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17352 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17353 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17354 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17355 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17356 pdf
->o_len
= o_len
;
17358 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17359 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17360 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17361 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17363 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17364 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17365 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17366 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17367 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17368 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17369 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17370 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17372 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17373 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17374 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17375 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17376 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17377 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17378 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17379 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17381 pdf
->rc4key
[1] = 0;
17382 pdf
->rc4key
[0] = 0;
17384 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17385 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17386 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17387 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17388 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17389 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17390 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17391 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17392 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17393 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17395 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17396 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17398 // we use ID for salt, maybe needs to change, we will see...
17400 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17401 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17402 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17403 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17404 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17405 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17406 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17407 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17408 salt
->salt_len
= pdf
->id_len
+ 16;
17410 digest
[0] = pdf
->rc4key
[0];
17411 digest
[1] = pdf
->rc4key
[1];
17415 return (PARSER_OK
);
17418 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17420 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17422 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17424 u32
*digest
= (u32
*) hash_buf
->digest
;
17426 salt_t
*salt
= hash_buf
->salt
;
17428 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17434 char *V_pos
= input_buf
+ 5;
17436 char *R_pos
= strchr (V_pos
, '*');
17438 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17440 u32 V_len
= R_pos
- V_pos
;
17444 char *bits_pos
= strchr (R_pos
, '*');
17446 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17448 u32 R_len
= bits_pos
- R_pos
;
17452 char *P_pos
= strchr (bits_pos
, '*');
17454 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17456 u32 bits_len
= P_pos
- bits_pos
;
17460 char *enc_md_pos
= strchr (P_pos
, '*');
17462 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17464 u32 P_len
= enc_md_pos
- P_pos
;
17468 char *id_len_pos
= strchr (enc_md_pos
, '*');
17470 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17472 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17476 char *id_buf_pos
= strchr (id_len_pos
, '*');
17478 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17480 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17484 char *u_len_pos
= strchr (id_buf_pos
, '*');
17486 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17488 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17490 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17494 char *u_buf_pos
= strchr (u_len_pos
, '*');
17496 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17498 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17502 char *o_len_pos
= strchr (u_buf_pos
, '*');
17504 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17506 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17508 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17512 char *o_buf_pos
= strchr (o_len_pos
, '*');
17514 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17516 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17520 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;
17522 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17526 const int V
= atoi (V_pos
);
17527 const int R
= atoi (R_pos
);
17528 const int P
= atoi (P_pos
);
17532 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17533 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17535 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17537 const int id_len
= atoi (id_len_pos
);
17538 const int u_len
= atoi (u_len_pos
);
17539 const int o_len
= atoi (o_len_pos
);
17541 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17543 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17544 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17546 const int bits
= atoi (bits_pos
);
17548 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17554 enc_md
= atoi (enc_md_pos
);
17557 // copy data to esalt
17563 pdf
->enc_md
= enc_md
;
17565 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17566 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17567 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17568 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17572 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17573 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17574 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17575 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17578 pdf
->id_len
= id_len
;
17580 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17581 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17582 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17583 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17584 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17585 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17586 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17587 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17588 pdf
->u_len
= u_len
;
17590 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17591 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17592 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17593 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17594 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17595 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17596 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17597 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17598 pdf
->o_len
= o_len
;
17600 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17601 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17602 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17603 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17607 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17608 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17609 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17610 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17613 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17614 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17615 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17616 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17617 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17618 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17619 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17620 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17622 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17623 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17624 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17625 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17626 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17627 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17628 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17629 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17631 // precompute rc4 data for later use
17647 uint salt_pc_block
[32] = { 0 };
17649 char *salt_pc_ptr
= (char *) salt_pc_block
;
17651 memcpy (salt_pc_ptr
, padding
, 32);
17652 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17654 uint salt_pc_digest
[4] = { 0 };
17656 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17658 pdf
->rc4data
[0] = salt_pc_digest
[0];
17659 pdf
->rc4data
[1] = salt_pc_digest
[1];
17661 // we use ID for salt, maybe needs to change, we will see...
17663 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17664 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17665 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17666 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17667 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17668 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17669 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17670 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17671 salt
->salt_len
= pdf
->id_len
+ 16;
17673 salt
->salt_iter
= ROUNDS_PDF14
;
17675 digest
[0] = pdf
->u_buf
[0];
17676 digest
[1] = pdf
->u_buf
[1];
17680 return (PARSER_OK
);
17683 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17685 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17687 if (ret
!= PARSER_OK
)
17692 u32
*digest
= (u32
*) hash_buf
->digest
;
17694 salt_t
*salt
= hash_buf
->salt
;
17696 digest
[0] -= SHA256M_A
;
17697 digest
[1] -= SHA256M_B
;
17698 digest
[2] -= SHA256M_C
;
17699 digest
[3] -= SHA256M_D
;
17700 digest
[4] -= SHA256M_E
;
17701 digest
[5] -= SHA256M_F
;
17702 digest
[6] -= SHA256M_G
;
17703 digest
[7] -= SHA256M_H
;
17705 salt
->salt_buf
[2] = 0x80;
17707 return (PARSER_OK
);
17710 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17712 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17714 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17716 u32
*digest
= (u32
*) hash_buf
->digest
;
17718 salt_t
*salt
= hash_buf
->salt
;
17720 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17726 char *V_pos
= input_buf
+ 5;
17728 char *R_pos
= strchr (V_pos
, '*');
17730 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17732 u32 V_len
= R_pos
- V_pos
;
17736 char *bits_pos
= strchr (R_pos
, '*');
17738 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17740 u32 R_len
= bits_pos
- R_pos
;
17744 char *P_pos
= strchr (bits_pos
, '*');
17746 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17748 u32 bits_len
= P_pos
- bits_pos
;
17752 char *enc_md_pos
= strchr (P_pos
, '*');
17754 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17756 u32 P_len
= enc_md_pos
- P_pos
;
17760 char *id_len_pos
= strchr (enc_md_pos
, '*');
17762 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17764 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17768 char *id_buf_pos
= strchr (id_len_pos
, '*');
17770 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17772 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17776 char *u_len_pos
= strchr (id_buf_pos
, '*');
17778 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17780 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17784 char *u_buf_pos
= strchr (u_len_pos
, '*');
17786 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17788 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17792 char *o_len_pos
= strchr (u_buf_pos
, '*');
17794 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17796 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17800 char *o_buf_pos
= strchr (o_len_pos
, '*');
17802 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17804 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17808 char *last
= strchr (o_buf_pos
, '*');
17810 if (last
== NULL
) last
= input_buf
+ input_len
;
17812 u32 o_buf_len
= last
- o_buf_pos
;
17816 const int V
= atoi (V_pos
);
17817 const int R
= atoi (R_pos
);
17821 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17822 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17824 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17826 const int bits
= atoi (bits_pos
);
17828 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17830 int enc_md
= atoi (enc_md_pos
);
17832 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17834 const uint id_len
= atoi (id_len_pos
);
17835 const uint u_len
= atoi (u_len_pos
);
17836 const uint o_len
= atoi (o_len_pos
);
17838 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17839 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17840 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17841 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17842 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17843 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17844 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17845 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17847 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17848 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17849 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17851 // copy data to esalt
17853 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17855 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17857 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17860 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17861 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17863 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17864 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17866 salt
->salt_len
= 8;
17867 salt
->salt_iter
= ROUNDS_PDF17L8
;
17869 digest
[0] = pdf
->u_buf
[0];
17870 digest
[1] = pdf
->u_buf
[1];
17871 digest
[2] = pdf
->u_buf
[2];
17872 digest
[3] = pdf
->u_buf
[3];
17873 digest
[4] = pdf
->u_buf
[4];
17874 digest
[5] = pdf
->u_buf
[5];
17875 digest
[6] = pdf
->u_buf
[6];
17876 digest
[7] = pdf
->u_buf
[7];
17878 return (PARSER_OK
);
17881 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17883 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17885 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17887 u32
*digest
= (u32
*) hash_buf
->digest
;
17889 salt_t
*salt
= hash_buf
->salt
;
17891 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17899 char *iter_pos
= input_buf
+ 7;
17901 u32 iter
= atoi (iter_pos
);
17903 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17904 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17906 // first is *raw* salt
17908 char *salt_pos
= strchr (iter_pos
, ':');
17910 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17914 char *hash_pos
= strchr (salt_pos
, ':');
17916 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17918 u32 salt_len
= hash_pos
- salt_pos
;
17920 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17924 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17926 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17930 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17932 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17934 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17936 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17937 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17939 salt
->salt_len
= salt_len
;
17940 salt
->salt_iter
= iter
- 1;
17944 u8 tmp_buf
[100] = { 0 };
17946 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17948 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17950 memcpy (digest
, tmp_buf
, 16);
17952 digest
[0] = byte_swap_32 (digest
[0]);
17953 digest
[1] = byte_swap_32 (digest
[1]);
17954 digest
[2] = byte_swap_32 (digest
[2]);
17955 digest
[3] = byte_swap_32 (digest
[3]);
17957 // add some stuff to normal salt to make sorted happy
17959 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17960 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17961 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17962 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17963 salt
->salt_buf
[4] = salt
->salt_iter
;
17965 return (PARSER_OK
);
17968 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17970 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17972 u32
*digest
= (u32
*) hash_buf
->digest
;
17974 salt_t
*salt
= hash_buf
->salt
;
17976 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17977 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17978 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17979 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17981 digest
[0] = byte_swap_32 (digest
[0]);
17982 digest
[1] = byte_swap_32 (digest
[1]);
17983 digest
[2] = byte_swap_32 (digest
[2]);
17984 digest
[3] = byte_swap_32 (digest
[3]);
17986 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17988 uint salt_len
= input_len
- 32 - 1;
17990 char *salt_buf
= input_buf
+ 32 + 1;
17992 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17994 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17996 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17998 salt
->salt_len
= salt_len
;
18000 return (PARSER_OK
);
18003 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18005 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18007 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18009 u32
*digest
= (u32
*) hash_buf
->digest
;
18011 salt_t
*salt
= hash_buf
->salt
;
18013 char *user_pos
= input_buf
+ 10;
18015 char *salt_pos
= strchr (user_pos
, '*');
18017 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18021 char *hash_pos
= strchr (salt_pos
, '*');
18025 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18027 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18029 uint user_len
= salt_pos
- user_pos
- 1;
18031 uint salt_len
= hash_pos
- salt_pos
- 1;
18033 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18039 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18040 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18041 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18042 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18044 digest
[0] = byte_swap_32 (digest
[0]);
18045 digest
[1] = byte_swap_32 (digest
[1]);
18046 digest
[2] = byte_swap_32 (digest
[2]);
18047 digest
[3] = byte_swap_32 (digest
[3]);
18049 digest
[0] -= MD5M_A
;
18050 digest
[1] -= MD5M_B
;
18051 digest
[2] -= MD5M_C
;
18052 digest
[3] -= MD5M_D
;
18058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18060 // first 4 bytes are the "challenge"
18062 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18063 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18064 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18065 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18067 // append the user name
18069 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18071 salt
->salt_len
= 4 + user_len
;
18073 return (PARSER_OK
);
18076 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18078 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18080 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18082 u32
*digest
= (u32
*) hash_buf
->digest
;
18084 salt_t
*salt
= hash_buf
->salt
;
18086 char *salt_pos
= input_buf
+ 9;
18088 char *hash_pos
= strchr (salt_pos
, '*');
18090 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18094 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18096 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18098 uint salt_len
= hash_pos
- salt_pos
- 1;
18100 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18106 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18107 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18108 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18109 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18110 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18116 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18118 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18120 salt
->salt_len
= salt_len
;
18122 return (PARSER_OK
);
18125 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18127 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18129 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18131 u32
*digest
= (u32
*) hash_buf
->digest
;
18133 salt_t
*salt
= hash_buf
->salt
;
18135 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18141 char *cry_master_len_pos
= input_buf
+ 9;
18143 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18145 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18147 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18149 cry_master_buf_pos
++;
18151 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18153 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18155 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18157 cry_salt_len_pos
++;
18159 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18161 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18163 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18165 cry_salt_buf_pos
++;
18167 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18169 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18171 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18175 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18177 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18179 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18183 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18185 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18187 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18191 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18193 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18197 public_key_len_pos
++;
18199 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18201 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18203 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18205 public_key_buf_pos
++;
18207 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;
18209 const uint cry_master_len
= atoi (cry_master_len_pos
);
18210 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18211 const uint ckey_len
= atoi (ckey_len_pos
);
18212 const uint public_key_len
= atoi (public_key_len_pos
);
18214 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18215 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18216 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18217 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18219 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18221 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18223 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18226 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18228 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18230 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18233 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18235 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18237 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18240 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18241 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18242 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18245 * store digest (should be unique enought, hopefully)
18248 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18249 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18250 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18251 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18257 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18259 const uint cry_rounds
= atoi (cry_rounds_pos
);
18261 salt
->salt_iter
= cry_rounds
- 1;
18263 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18265 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18267 salt
->salt_len
= salt_len
;
18269 return (PARSER_OK
);
18272 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18274 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18276 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18278 u32
*digest
= (u32
*) hash_buf
->digest
;
18280 salt_t
*salt
= hash_buf
->salt
;
18282 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18284 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18286 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18288 memcpy (temp_input_buf
, input_buf
, input_len
);
18292 char *URI_server_pos
= temp_input_buf
+ 6;
18294 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18296 if (URI_client_pos
== NULL
)
18298 myfree (temp_input_buf
);
18300 return (PARSER_SEPARATOR_UNMATCHED
);
18303 URI_client_pos
[0] = 0;
18306 uint URI_server_len
= strlen (URI_server_pos
);
18308 if (URI_server_len
> 512)
18310 myfree (temp_input_buf
);
18312 return (PARSER_SALT_LENGTH
);
18317 char *user_pos
= strchr (URI_client_pos
, '*');
18319 if (user_pos
== NULL
)
18321 myfree (temp_input_buf
);
18323 return (PARSER_SEPARATOR_UNMATCHED
);
18329 uint URI_client_len
= strlen (URI_client_pos
);
18331 if (URI_client_len
> 512)
18333 myfree (temp_input_buf
);
18335 return (PARSER_SALT_LENGTH
);
18340 char *realm_pos
= strchr (user_pos
, '*');
18342 if (realm_pos
== NULL
)
18344 myfree (temp_input_buf
);
18346 return (PARSER_SEPARATOR_UNMATCHED
);
18352 uint user_len
= strlen (user_pos
);
18354 if (user_len
> 116)
18356 myfree (temp_input_buf
);
18358 return (PARSER_SALT_LENGTH
);
18363 char *method_pos
= strchr (realm_pos
, '*');
18365 if (method_pos
== NULL
)
18367 myfree (temp_input_buf
);
18369 return (PARSER_SEPARATOR_UNMATCHED
);
18375 uint realm_len
= strlen (realm_pos
);
18377 if (realm_len
> 116)
18379 myfree (temp_input_buf
);
18381 return (PARSER_SALT_LENGTH
);
18386 char *URI_prefix_pos
= strchr (method_pos
, '*');
18388 if (URI_prefix_pos
== NULL
)
18390 myfree (temp_input_buf
);
18392 return (PARSER_SEPARATOR_UNMATCHED
);
18395 URI_prefix_pos
[0] = 0;
18398 uint method_len
= strlen (method_pos
);
18400 if (method_len
> 246)
18402 myfree (temp_input_buf
);
18404 return (PARSER_SALT_LENGTH
);
18409 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18411 if (URI_resource_pos
== NULL
)
18413 myfree (temp_input_buf
);
18415 return (PARSER_SEPARATOR_UNMATCHED
);
18418 URI_resource_pos
[0] = 0;
18419 URI_resource_pos
++;
18421 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18423 if (URI_prefix_len
> 245)
18425 myfree (temp_input_buf
);
18427 return (PARSER_SALT_LENGTH
);
18432 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18434 if (URI_suffix_pos
== NULL
)
18436 myfree (temp_input_buf
);
18438 return (PARSER_SEPARATOR_UNMATCHED
);
18441 URI_suffix_pos
[0] = 0;
18444 uint URI_resource_len
= strlen (URI_resource_pos
);
18446 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18448 myfree (temp_input_buf
);
18450 return (PARSER_SALT_LENGTH
);
18455 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18457 if (nonce_pos
== NULL
)
18459 myfree (temp_input_buf
);
18461 return (PARSER_SEPARATOR_UNMATCHED
);
18467 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18469 if (URI_suffix_len
> 245)
18471 myfree (temp_input_buf
);
18473 return (PARSER_SALT_LENGTH
);
18478 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18480 if (nonce_client_pos
== NULL
)
18482 myfree (temp_input_buf
);
18484 return (PARSER_SEPARATOR_UNMATCHED
);
18487 nonce_client_pos
[0] = 0;
18488 nonce_client_pos
++;
18490 uint nonce_len
= strlen (nonce_pos
);
18492 if (nonce_len
< 1 || nonce_len
> 50)
18494 myfree (temp_input_buf
);
18496 return (PARSER_SALT_LENGTH
);
18501 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18503 if (nonce_count_pos
== NULL
)
18505 myfree (temp_input_buf
);
18507 return (PARSER_SEPARATOR_UNMATCHED
);
18510 nonce_count_pos
[0] = 0;
18513 uint nonce_client_len
= strlen (nonce_client_pos
);
18515 if (nonce_client_len
> 50)
18517 myfree (temp_input_buf
);
18519 return (PARSER_SALT_LENGTH
);
18524 char *qop_pos
= strchr (nonce_count_pos
, '*');
18526 if (qop_pos
== NULL
)
18528 myfree (temp_input_buf
);
18530 return (PARSER_SEPARATOR_UNMATCHED
);
18536 uint nonce_count_len
= strlen (nonce_count_pos
);
18538 if (nonce_count_len
> 50)
18540 myfree (temp_input_buf
);
18542 return (PARSER_SALT_LENGTH
);
18547 char *directive_pos
= strchr (qop_pos
, '*');
18549 if (directive_pos
== NULL
)
18551 myfree (temp_input_buf
);
18553 return (PARSER_SEPARATOR_UNMATCHED
);
18556 directive_pos
[0] = 0;
18559 uint qop_len
= strlen (qop_pos
);
18563 myfree (temp_input_buf
);
18565 return (PARSER_SALT_LENGTH
);
18570 char *digest_pos
= strchr (directive_pos
, '*');
18572 if (digest_pos
== NULL
)
18574 myfree (temp_input_buf
);
18576 return (PARSER_SEPARATOR_UNMATCHED
);
18582 uint directive_len
= strlen (directive_pos
);
18584 if (directive_len
!= 3)
18586 myfree (temp_input_buf
);
18588 return (PARSER_SALT_LENGTH
);
18591 if (memcmp (directive_pos
, "MD5", 3))
18593 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18595 myfree (temp_input_buf
);
18597 return (PARSER_SIP_AUTH_DIRECTIVE
);
18601 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18606 uint md5_max_len
= 4 * 64;
18608 uint md5_remaining_len
= md5_max_len
;
18610 uint tmp_md5_buf
[64] = { 0 };
18612 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18614 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18616 md5_len
+= method_len
+ 1;
18617 tmp_md5_ptr
+= method_len
+ 1;
18619 if (URI_prefix_len
> 0)
18621 md5_remaining_len
= md5_max_len
- md5_len
;
18623 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18625 md5_len
+= URI_prefix_len
+ 1;
18626 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18629 md5_remaining_len
= md5_max_len
- md5_len
;
18631 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18633 md5_len
+= URI_resource_len
;
18634 tmp_md5_ptr
+= URI_resource_len
;
18636 if (URI_suffix_len
> 0)
18638 md5_remaining_len
= md5_max_len
- md5_len
;
18640 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18642 md5_len
+= 1 + URI_suffix_len
;
18645 uint tmp_digest
[4] = { 0 };
18647 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18649 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18650 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18651 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18652 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18658 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18660 uint esalt_len
= 0;
18662 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18664 // there are 2 possibilities for the esalt:
18666 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18668 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18670 if (esalt_len
> max_esalt_len
)
18672 myfree (temp_input_buf
);
18674 return (PARSER_SALT_LENGTH
);
18677 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18689 esalt_len
= 1 + nonce_len
+ 1 + 32;
18691 if (esalt_len
> max_esalt_len
)
18693 myfree (temp_input_buf
);
18695 return (PARSER_SALT_LENGTH
);
18698 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18706 // add 0x80 to esalt
18708 esalt_buf_ptr
[esalt_len
] = 0x80;
18710 sip
->esalt_len
= esalt_len
;
18716 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18718 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18720 uint max_salt_len
= 119;
18722 if (salt_len
> max_salt_len
)
18724 myfree (temp_input_buf
);
18726 return (PARSER_SALT_LENGTH
);
18729 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18731 sip
->salt_len
= salt_len
;
18734 * fake salt (for sorting)
18737 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18741 uint fake_salt_len
= salt_len
;
18743 if (fake_salt_len
> max_salt_len
)
18745 fake_salt_len
= max_salt_len
;
18748 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18750 salt
->salt_len
= fake_salt_len
;
18756 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18757 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18758 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18759 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18761 digest
[0] = byte_swap_32 (digest
[0]);
18762 digest
[1] = byte_swap_32 (digest
[1]);
18763 digest
[2] = byte_swap_32 (digest
[2]);
18764 digest
[3] = byte_swap_32 (digest
[3]);
18766 myfree (temp_input_buf
);
18768 return (PARSER_OK
);
18771 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18773 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18775 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18777 u32
*digest
= (u32
*) hash_buf
->digest
;
18779 salt_t
*salt
= hash_buf
->salt
;
18783 char *digest_pos
= input_buf
;
18785 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18792 char *salt_buf
= input_buf
+ 8 + 1;
18796 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18798 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18800 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18802 salt
->salt_len
= salt_len
;
18804 return (PARSER_OK
);
18807 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18809 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18811 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18813 u32
*digest
= (u32
*) hash_buf
->digest
;
18815 salt_t
*salt
= hash_buf
->salt
;
18817 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18823 char *p_buf_pos
= input_buf
+ 4;
18825 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18827 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18829 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18831 NumCyclesPower_pos
++;
18833 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18835 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18837 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18841 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18843 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18845 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18849 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18851 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18853 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18857 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18859 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18861 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18865 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18867 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18869 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18873 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18875 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18877 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18881 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18883 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18885 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18889 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18891 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18893 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18897 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;
18899 const uint iter
= atoi (NumCyclesPower_pos
);
18900 const uint crc
= atoi (crc_buf_pos
);
18901 const uint p_buf
= atoi (p_buf_pos
);
18902 const uint salt_len
= atoi (salt_len_pos
);
18903 const uint iv_len
= atoi (iv_len_pos
);
18904 const uint unpack_size
= atoi (unpack_size_pos
);
18905 const uint data_len
= atoi (data_len_pos
);
18911 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18912 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18914 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18916 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18918 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18924 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18925 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18926 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18927 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18929 seven_zip
->iv_len
= iv_len
;
18931 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18933 seven_zip
->salt_len
= 0;
18935 seven_zip
->crc
= crc
;
18937 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18939 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18941 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18944 seven_zip
->data_len
= data_len
;
18946 seven_zip
->unpack_size
= unpack_size
;
18950 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18951 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18952 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18953 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18955 salt
->salt_len
= 16;
18957 salt
->salt_sign
[0] = iter
;
18959 salt
->salt_iter
= 1 << iter
;
18970 return (PARSER_OK
);
18973 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18975 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18977 u32
*digest
= (u32
*) hash_buf
->digest
;
18979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18983 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18984 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18985 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18986 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18988 digest
[0] = byte_swap_32 (digest
[0]);
18989 digest
[1] = byte_swap_32 (digest
[1]);
18990 digest
[2] = byte_swap_32 (digest
[2]);
18991 digest
[3] = byte_swap_32 (digest
[3]);
18992 digest
[4] = byte_swap_32 (digest
[4]);
18993 digest
[5] = byte_swap_32 (digest
[5]);
18994 digest
[6] = byte_swap_32 (digest
[6]);
18995 digest
[7] = byte_swap_32 (digest
[7]);
18997 return (PARSER_OK
);
19000 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19002 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19004 u32
*digest
= (u32
*) hash_buf
->digest
;
19006 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19007 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19008 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19009 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19010 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19011 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19012 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19013 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19014 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19015 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19016 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19017 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19018 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19019 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19020 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19021 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19023 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19024 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19025 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19026 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19027 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19028 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19029 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19030 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19031 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19032 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19033 digest
[10] = byte_swap_32 (digest
[10]);
19034 digest
[11] = byte_swap_32 (digest
[11]);
19035 digest
[12] = byte_swap_32 (digest
[12]);
19036 digest
[13] = byte_swap_32 (digest
[13]);
19037 digest
[14] = byte_swap_32 (digest
[14]);
19038 digest
[15] = byte_swap_32 (digest
[15]);
19040 return (PARSER_OK
);
19043 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19045 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19047 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19049 u32
*digest
= (u32
*) hash_buf
->digest
;
19051 salt_t
*salt
= hash_buf
->salt
;
19053 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19061 char *iter_pos
= input_buf
+ 4;
19063 u32 iter
= atoi (iter_pos
);
19065 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19066 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19068 // first is *raw* salt
19070 char *salt_pos
= strchr (iter_pos
, ':');
19072 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19076 char *hash_pos
= strchr (salt_pos
, ':');
19078 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19080 u32 salt_len
= hash_pos
- salt_pos
;
19082 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19086 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19088 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19092 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19094 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19096 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19098 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19099 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19101 salt
->salt_len
= salt_len
;
19102 salt
->salt_iter
= iter
- 1;
19106 u8 tmp_buf
[100] = { 0 };
19108 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19110 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19112 memcpy (digest
, tmp_buf
, 16);
19114 // add some stuff to normal salt to make sorted happy
19116 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19117 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19118 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19119 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19120 salt
->salt_buf
[4] = salt
->salt_iter
;
19122 return (PARSER_OK
);
19125 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19127 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19129 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19131 u32
*digest
= (u32
*) hash_buf
->digest
;
19133 salt_t
*salt
= hash_buf
->salt
;
19135 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19143 char *iter_pos
= input_buf
+ 5;
19145 u32 iter
= atoi (iter_pos
);
19147 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19148 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19150 // first is *raw* salt
19152 char *salt_pos
= strchr (iter_pos
, ':');
19154 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19158 char *hash_pos
= strchr (salt_pos
, ':');
19160 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19162 u32 salt_len
= hash_pos
- salt_pos
;
19164 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19168 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19170 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19174 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19176 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19178 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19180 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19181 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19183 salt
->salt_len
= salt_len
;
19184 salt
->salt_iter
= iter
- 1;
19188 u8 tmp_buf
[100] = { 0 };
19190 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19192 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19194 memcpy (digest
, tmp_buf
, 16);
19196 digest
[0] = byte_swap_32 (digest
[0]);
19197 digest
[1] = byte_swap_32 (digest
[1]);
19198 digest
[2] = byte_swap_32 (digest
[2]);
19199 digest
[3] = byte_swap_32 (digest
[3]);
19201 // add some stuff to normal salt to make sorted happy
19203 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19204 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19205 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19206 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19207 salt
->salt_buf
[4] = salt
->salt_iter
;
19209 return (PARSER_OK
);
19212 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19214 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19216 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19218 u64
*digest
= (u64
*) hash_buf
->digest
;
19220 salt_t
*salt
= hash_buf
->salt
;
19222 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19230 char *iter_pos
= input_buf
+ 7;
19232 u32 iter
= atoi (iter_pos
);
19234 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19235 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19237 // first is *raw* salt
19239 char *salt_pos
= strchr (iter_pos
, ':');
19241 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19245 char *hash_pos
= strchr (salt_pos
, ':');
19247 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19249 u32 salt_len
= hash_pos
- salt_pos
;
19251 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19255 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19257 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19261 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19265 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19267 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19268 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19270 salt
->salt_len
= salt_len
;
19271 salt
->salt_iter
= iter
- 1;
19275 u8 tmp_buf
[100] = { 0 };
19277 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19279 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19281 memcpy (digest
, tmp_buf
, 64);
19283 digest
[0] = byte_swap_64 (digest
[0]);
19284 digest
[1] = byte_swap_64 (digest
[1]);
19285 digest
[2] = byte_swap_64 (digest
[2]);
19286 digest
[3] = byte_swap_64 (digest
[3]);
19287 digest
[4] = byte_swap_64 (digest
[4]);
19288 digest
[5] = byte_swap_64 (digest
[5]);
19289 digest
[6] = byte_swap_64 (digest
[6]);
19290 digest
[7] = byte_swap_64 (digest
[7]);
19292 // add some stuff to normal salt to make sorted happy
19294 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19295 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19296 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19297 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19298 salt
->salt_buf
[4] = salt
->salt_iter
;
19300 return (PARSER_OK
);
19303 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19305 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19307 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19309 uint
*digest
= (uint
*) hash_buf
->digest
;
19311 salt_t
*salt
= hash_buf
->salt
;
19317 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19319 char *hash_pos
= strchr (salt_pos
, '$');
19321 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19323 u32 salt_len
= hash_pos
- salt_pos
;
19325 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19329 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19331 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19335 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19336 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19354 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19355 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19357 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19358 salt
->salt_len
= 8;
19360 return (PARSER_OK
);
19363 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19365 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19367 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19369 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19371 if (c19
& 3) return (PARSER_HASH_VALUE
);
19373 salt_t
*salt
= hash_buf
->salt
;
19375 u32
*digest
= (u32
*) hash_buf
->digest
;
19379 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19380 | itoa64_to_int (input_buf
[2]) << 6
19381 | itoa64_to_int (input_buf
[3]) << 12
19382 | itoa64_to_int (input_buf
[4]) << 18;
19386 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19387 | itoa64_to_int (input_buf
[6]) << 6
19388 | itoa64_to_int (input_buf
[7]) << 12
19389 | itoa64_to_int (input_buf
[8]) << 18;
19391 salt
->salt_len
= 4;
19393 u8 tmp_buf
[100] = { 0 };
19395 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19397 memcpy (digest
, tmp_buf
, 8);
19401 IP (digest
[0], digest
[1], tt
);
19403 digest
[0] = rotr32 (digest
[0], 31);
19404 digest
[1] = rotr32 (digest
[1], 31);
19408 return (PARSER_OK
);
19411 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19413 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19415 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19417 u32
*digest
= (u32
*) hash_buf
->digest
;
19419 salt_t
*salt
= hash_buf
->salt
;
19425 char *type_pos
= input_buf
+ 6 + 1;
19427 char *salt_pos
= strchr (type_pos
, '*');
19429 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19431 u32 type_len
= salt_pos
- type_pos
;
19433 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19437 char *crypted_pos
= strchr (salt_pos
, '*');
19439 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19441 u32 salt_len
= crypted_pos
- salt_pos
;
19443 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19447 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19449 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19455 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19456 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19458 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19459 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19461 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19462 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19463 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19464 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19466 salt
->salt_len
= 24;
19467 salt
->salt_iter
= ROUNDS_RAR3
;
19469 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19470 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19472 digest
[0] = 0xc43d7b00;
19473 digest
[1] = 0x40070000;
19477 return (PARSER_OK
);
19480 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19482 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19484 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19486 u32
*digest
= (u32
*) hash_buf
->digest
;
19488 salt_t
*salt
= hash_buf
->salt
;
19490 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19496 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19498 char *param1_pos
= strchr (param0_pos
, '$');
19500 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19502 u32 param0_len
= param1_pos
- param0_pos
;
19506 char *param2_pos
= strchr (param1_pos
, '$');
19508 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19510 u32 param1_len
= param2_pos
- param1_pos
;
19514 char *param3_pos
= strchr (param2_pos
, '$');
19516 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19518 u32 param2_len
= param3_pos
- param2_pos
;
19522 char *param4_pos
= strchr (param3_pos
, '$');
19524 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19526 u32 param3_len
= param4_pos
- param3_pos
;
19530 char *param5_pos
= strchr (param4_pos
, '$');
19532 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19534 u32 param4_len
= param5_pos
- param4_pos
;
19538 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19540 char *salt_buf
= param1_pos
;
19541 char *iv
= param3_pos
;
19542 char *pswcheck
= param5_pos
;
19544 const uint salt_len
= atoi (param0_pos
);
19545 const uint iterations
= atoi (param2_pos
);
19546 const uint pswcheck_len
= atoi (param4_pos
);
19552 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19553 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19554 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19556 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19557 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19558 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19564 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19565 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19566 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19567 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19569 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19570 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19571 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19572 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19574 salt
->salt_len
= 16;
19576 salt
->salt_sign
[0] = iterations
;
19578 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19584 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19585 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19589 return (PARSER_OK
);
19592 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19594 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19596 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19598 u32
*digest
= (u32
*) hash_buf
->digest
;
19600 salt_t
*salt
= hash_buf
->salt
;
19602 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19609 char *account_pos
= input_buf
+ 11 + 1;
19615 if (account_pos
[0] == '*')
19619 data_pos
= strchr (account_pos
, '*');
19624 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19626 uint account_len
= data_pos
- account_pos
+ 1;
19628 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19633 data_len
= input_len
- 11 - 1 - account_len
- 2;
19635 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19639 /* assume $krb5tgs$23$checksum$edata2 */
19640 data_pos
= account_pos
;
19642 memcpy (krb5tgs
->account_info
, "**", 3);
19644 data_len
= input_len
- 11 - 1 - 1;
19647 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19649 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19651 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19653 const char p0
= data_pos
[i
+ 0];
19654 const char p1
= data_pos
[i
+ 1];
19656 *checksum_ptr
++ = hex_convert (p1
) << 0
19657 | hex_convert (p0
) << 4;
19660 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19662 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19665 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19667 const char p0
= data_pos
[i
+ 0];
19668 const char p1
= data_pos
[i
+ 1];
19669 *edata_ptr
++ = hex_convert (p1
) << 0
19670 | hex_convert (p0
) << 4;
19673 /* this is needed for hmac_md5 */
19674 *edata_ptr
++ = 0x80;
19676 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19677 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19678 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19679 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19681 salt
->salt_len
= 32;
19683 digest
[0] = krb5tgs
->checksum
[0];
19684 digest
[1] = krb5tgs
->checksum
[1];
19685 digest
[2] = krb5tgs
->checksum
[2];
19686 digest
[3] = krb5tgs
->checksum
[3];
19688 return (PARSER_OK
);
19691 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19693 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19695 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19697 u32
*digest
= (u32
*) hash_buf
->digest
;
19699 salt_t
*salt
= hash_buf
->salt
;
19706 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19710 char *wrapped_key_pos
;
19714 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19716 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19718 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19720 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19725 data_pos
= salt_pos
;
19727 wrapped_key_pos
= strchr (salt_pos
, '*');
19729 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19731 uint salt_len
= wrapped_key_pos
- salt_pos
;
19733 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19738 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19740 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19742 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19743 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19744 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19745 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19749 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19750 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19751 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19752 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19753 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19754 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19756 salt
->salt_len
= 40;
19758 digest
[0] = salt
->salt_buf
[0];
19759 digest
[1] = salt
->salt_buf
[1];
19760 digest
[2] = salt
->salt_buf
[2];
19761 digest
[3] = salt
->salt_buf
[3];
19763 return (PARSER_OK
);
19766 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19768 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19770 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19772 u32
*digest
= (u32
*) hash_buf
->digest
;
19774 salt_t
*salt
= hash_buf
->salt
;
19776 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19786 char *algorithm_pos
;
19788 char *final_random_seed_pos
;
19789 u32 final_random_seed_len
;
19791 char *transf_random_seed_pos
;
19792 u32 transf_random_seed_len
;
19797 /* default is no keyfile provided */
19798 char *keyfile_len_pos
;
19799 u32 keyfile_len
= 0;
19800 u32 is_keyfile_present
= 0;
19801 char *keyfile_inline_pos
;
19804 /* specific to version 1 */
19805 char *contents_len_pos
;
19807 char *contents_pos
;
19809 /* specific to version 2 */
19810 char *expected_bytes_pos
;
19811 u32 expected_bytes_len
;
19813 char *contents_hash_pos
;
19814 u32 contents_hash_len
;
19816 version_pos
= input_buf
+ 8 + 1 + 1;
19818 keepass
->version
= atoi (version_pos
);
19820 rounds_pos
= strchr (version_pos
, '*');
19822 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19826 salt
->salt_iter
= (atoi (rounds_pos
));
19828 algorithm_pos
= strchr (rounds_pos
, '*');
19830 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19834 keepass
->algorithm
= atoi (algorithm_pos
);
19836 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19838 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19840 final_random_seed_pos
++;
19842 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19843 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19844 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19845 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19847 if (keepass
->version
== 2)
19849 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19850 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19851 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19852 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19855 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19857 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19859 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19861 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19862 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19864 transf_random_seed_pos
++;
19866 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19867 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19868 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19869 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19870 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19871 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19872 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19873 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19875 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19877 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19879 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19881 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19885 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19886 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19887 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19888 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19890 if (keepass
->version
== 1)
19892 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19894 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19896 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19898 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19900 contents_hash_pos
++;
19902 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19903 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19904 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19905 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19906 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19907 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19908 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19909 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19911 /* get length of contents following */
19912 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19914 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19916 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19918 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19922 u32 inline_flag
= atoi (inline_flag_pos
);
19924 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19926 contents_len_pos
= strchr (inline_flag_pos
, '*');
19928 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19930 contents_len_pos
++;
19932 contents_len
= atoi (contents_len_pos
);
19934 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19936 contents_pos
= strchr (contents_len_pos
, '*');
19938 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19944 keepass
->contents_len
= contents_len
;
19946 contents_len
= contents_len
/ 4;
19948 keyfile_inline_pos
= strchr (contents_pos
, '*');
19950 u32 real_contents_len
;
19952 if (keyfile_inline_pos
== NULL
)
19953 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19956 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19957 keyfile_inline_pos
++;
19958 is_keyfile_present
= 1;
19961 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19963 for (i
= 0; i
< contents_len
; i
++)
19964 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19966 else if (keepass
->version
== 2)
19968 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19970 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19972 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19974 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19976 expected_bytes_pos
++;
19978 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19979 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19980 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19981 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19982 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19983 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19984 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19985 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19987 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19989 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19991 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19993 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19995 contents_hash_pos
++;
19997 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19998 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19999 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20000 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20001 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20002 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20003 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20004 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20006 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20008 if (keyfile_inline_pos
== NULL
)
20009 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20012 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20013 keyfile_inline_pos
++;
20014 is_keyfile_present
= 1;
20016 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20019 if (is_keyfile_present
!= 0)
20021 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20025 keyfile_len
= atoi (keyfile_len_pos
);
20027 keepass
->keyfile_len
= keyfile_len
;
20029 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20031 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20033 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20037 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20039 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20041 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20042 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20043 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20044 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20045 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20046 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20047 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20048 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20051 digest
[0] = keepass
->enc_iv
[0];
20052 digest
[1] = keepass
->enc_iv
[1];
20053 digest
[2] = keepass
->enc_iv
[2];
20054 digest
[3] = keepass
->enc_iv
[3];
20056 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20057 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20058 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20059 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20060 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20061 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20062 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20063 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20065 return (PARSER_OK
);
20068 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20070 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20072 u32
*digest
= (u32
*) hash_buf
->digest
;
20074 salt_t
*salt
= hash_buf
->salt
;
20076 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20077 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20078 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20079 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20080 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20081 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20082 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20083 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20085 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20087 uint salt_len
= input_len
- 64 - 1;
20089 char *salt_buf
= input_buf
+ 64 + 1;
20091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20093 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20097 salt
->salt_len
= salt_len
;
20100 * we can precompute the first sha256 transform
20103 uint w
[16] = { 0 };
20105 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20106 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20107 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20108 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20109 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20110 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20111 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20112 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20113 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20114 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20115 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20116 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20117 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20118 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20119 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20120 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20122 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20124 sha256_64 (w
, pc256
);
20126 salt
->salt_buf_pc
[0] = pc256
[0];
20127 salt
->salt_buf_pc
[1] = pc256
[1];
20128 salt
->salt_buf_pc
[2] = pc256
[2];
20129 salt
->salt_buf_pc
[3] = pc256
[3];
20130 salt
->salt_buf_pc
[4] = pc256
[4];
20131 salt
->salt_buf_pc
[5] = pc256
[5];
20132 salt
->salt_buf_pc
[6] = pc256
[6];
20133 salt
->salt_buf_pc
[7] = pc256
[7];
20135 digest
[0] -= pc256
[0];
20136 digest
[1] -= pc256
[1];
20137 digest
[2] -= pc256
[2];
20138 digest
[3] -= pc256
[3];
20139 digest
[4] -= pc256
[4];
20140 digest
[5] -= pc256
[5];
20141 digest
[6] -= pc256
[6];
20142 digest
[7] -= pc256
[7];
20144 return (PARSER_OK
);
20147 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20149 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20151 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20153 u32
*digest
= (u32
*) hash_buf
->digest
;
20155 salt_t
*salt
= hash_buf
->salt
;
20161 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20163 char *data_buf_pos
= strchr (data_len_pos
, '$');
20165 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20167 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20169 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20170 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20174 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20176 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20178 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20180 u32 data_len
= atoi (data_len_pos
);
20182 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20188 char *salt_pos
= data_buf_pos
;
20190 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20191 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20192 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20193 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20195 // this is actually the CT, which is also the hash later (if matched)
20197 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20198 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20199 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20200 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20202 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20204 salt
->salt_iter
= 10 - 1;
20210 digest
[0] = salt
->salt_buf
[4];
20211 digest
[1] = salt
->salt_buf
[5];
20212 digest
[2] = salt
->salt_buf
[6];
20213 digest
[3] = salt
->salt_buf
[7];
20215 return (PARSER_OK
);
20218 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20220 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20222 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20224 u32
*digest
= (u32
*) hash_buf
->digest
;
20226 salt_t
*salt
= hash_buf
->salt
;
20232 char *salt_pos
= input_buf
+ 11 + 1;
20234 char *iter_pos
= strchr (salt_pos
, ',');
20236 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20238 u32 salt_len
= iter_pos
- salt_pos
;
20240 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20244 char *hash_pos
= strchr (iter_pos
, ',');
20246 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20248 u32 iter_len
= hash_pos
- iter_pos
;
20250 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20254 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20256 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20262 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20263 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20264 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20265 salt
->salt_buf
[3] = 0x00018000;
20267 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20268 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20269 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20270 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20272 salt
->salt_len
= salt_len
/ 2;
20274 salt
->salt_iter
= atoi (iter_pos
) - 1;
20280 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20281 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20282 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20283 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20284 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20285 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20286 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20287 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20289 return (PARSER_OK
);
20292 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20294 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20296 u32
*digest
= (u32
*) hash_buf
->digest
;
20298 salt_t
*salt
= hash_buf
->salt
;
20304 char *hash_pos
= input_buf
+ 64;
20305 char *salt1_pos
= input_buf
+ 128;
20306 char *salt2_pos
= input_buf
;
20312 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20313 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20314 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20315 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20317 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20318 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20319 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20320 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20322 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20323 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20324 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20325 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20327 salt
->salt_len
= 48;
20329 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20335 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20336 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20337 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20338 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20339 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20340 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20341 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20342 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20344 return (PARSER_OK
);
20347 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20349 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20351 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20352 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20354 u32
*digest
= (u32
*) hash_buf
->digest
;
20356 salt_t
*salt
= hash_buf
->salt
;
20358 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20364 char *param0_pos
= input_buf
+ 6 + 1;
20366 char *param1_pos
= strchr (param0_pos
, '*');
20368 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20370 u32 param0_len
= param1_pos
- param0_pos
;
20374 char *param2_pos
= strchr (param1_pos
, '*');
20376 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20378 u32 param1_len
= param2_pos
- param1_pos
;
20382 char *param3_pos
= strchr (param2_pos
, '*');
20384 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20386 u32 param2_len
= param3_pos
- param2_pos
;
20390 char *param4_pos
= strchr (param3_pos
, '*');
20392 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20394 u32 param3_len
= param4_pos
- param3_pos
;
20398 char *param5_pos
= strchr (param4_pos
, '*');
20400 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20402 u32 param4_len
= param5_pos
- param4_pos
;
20406 char *param6_pos
= strchr (param5_pos
, '*');
20408 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20410 u32 param5_len
= param6_pos
- param5_pos
;
20414 char *param7_pos
= strchr (param6_pos
, '*');
20416 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20418 u32 param6_len
= param7_pos
- param6_pos
;
20422 char *param8_pos
= strchr (param7_pos
, '*');
20424 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20426 u32 param7_len
= param8_pos
- param7_pos
;
20430 const uint type
= atoi (param0_pos
);
20431 const uint mode
= atoi (param1_pos
);
20432 const uint magic
= atoi (param2_pos
);
20434 char *salt_buf
= param3_pos
;
20436 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20438 const uint compress_length
= atoi (param5_pos
);
20440 char *data_buf
= param6_pos
;
20441 char *auth
= param7_pos
;
20447 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20449 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20451 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20453 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20455 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20457 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20459 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20461 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20463 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20465 if (type
!= 0) return (PARSER_SALT_VALUE
);
20467 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20469 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20471 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20479 zip2
->magic
= magic
;
20483 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20484 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20485 zip2
->salt_buf
[2] = 0;
20486 zip2
->salt_buf
[3] = 0;
20488 zip2
->salt_len
= 8;
20490 else if (mode
== 2)
20492 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20493 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20494 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20495 zip2
->salt_buf
[3] = 0;
20497 zip2
->salt_len
= 12;
20499 else if (mode
== 3)
20501 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20502 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20503 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20504 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20506 zip2
->salt_len
= 16;
20509 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20510 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20511 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20512 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20514 zip2
->verify_bytes
= verify_bytes
;
20516 zip2
->compress_length
= compress_length
;
20518 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20520 for (uint i
= 0; i
< param6_len
; i
+= 2)
20522 const char p0
= data_buf
[i
+ 0];
20523 const char p1
= data_buf
[i
+ 1];
20525 *data_buf_ptr
++ = hex_convert (p1
) << 0
20526 | hex_convert (p0
) << 4;
20531 *data_buf_ptr
= 0x80;
20533 char *auth_ptr
= (char *) zip2
->auth_buf
;
20535 for (uint i
= 0; i
< param7_len
; i
+= 2)
20537 const char p0
= auth
[i
+ 0];
20538 const char p1
= auth
[i
+ 1];
20540 *auth_ptr
++ = hex_convert (p1
) << 0
20541 | hex_convert (p0
) << 4;
20550 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20551 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20552 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20553 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20554 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20555 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20556 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20557 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20559 salt
->salt_len
= 32;
20561 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20564 * digest buf (fake)
20567 digest
[0] = zip2
->auth_buf
[0];
20568 digest
[1] = zip2
->auth_buf
[1];
20569 digest
[2] = zip2
->auth_buf
[2];
20570 digest
[3] = zip2
->auth_buf
[3];
20572 return (PARSER_OK
);
20575 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20577 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20579 u32
*digest
= (u32
*) hash_buf
->digest
;
20581 salt_t
*salt
= hash_buf
->salt
;
20583 win8phone_t
*esalt
= hash_buf
->esalt
;
20585 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20586 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20587 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20588 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20589 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20590 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20591 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20592 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20594 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20596 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20598 u32
*salt_buf
= esalt
->salt_buf
;
20600 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20602 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20605 salt
->salt_buf
[0] = salt_buf
[0];
20606 salt
->salt_buf
[1] = salt_buf
[1];
20607 salt
->salt_buf
[2] = salt_buf
[2];
20608 salt
->salt_buf
[3] = salt_buf
[3];
20609 salt
->salt_buf
[4] = salt_buf
[4];
20610 salt
->salt_buf
[5] = salt_buf
[5];
20611 salt
->salt_buf
[6] = salt_buf
[6];
20612 salt
->salt_buf
[7] = salt_buf
[7];
20614 salt
->salt_len
= 64;
20616 return (PARSER_OK
);
20620 * parallel running threads
20625 BOOL WINAPI
sigHandler_default (DWORD sig
)
20629 case CTRL_CLOSE_EVENT
:
20632 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20633 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20634 * function otherwise it is too late (e.g. after returning from this function)
20639 SetConsoleCtrlHandler (NULL
, TRUE
);
20646 case CTRL_LOGOFF_EVENT
:
20647 case CTRL_SHUTDOWN_EVENT
:
20651 SetConsoleCtrlHandler (NULL
, TRUE
);
20659 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20663 case CTRL_CLOSE_EVENT
:
20667 SetConsoleCtrlHandler (NULL
, TRUE
);
20674 case CTRL_LOGOFF_EVENT
:
20675 case CTRL_SHUTDOWN_EVENT
:
20679 SetConsoleCtrlHandler (NULL
, TRUE
);
20687 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20689 if (callback
== NULL
)
20691 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20695 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20701 void sigHandler_default (int sig
)
20705 signal (sig
, NULL
);
20708 void sigHandler_benchmark (int sig
)
20712 signal (sig
, NULL
);
20715 void hc_signal (void (callback
) (int))
20717 if (callback
== NULL
) callback
= SIG_DFL
;
20719 signal (SIGINT
, callback
);
20720 signal (SIGTERM
, callback
);
20721 signal (SIGABRT
, callback
);
20726 void status_display ();
20728 void *thread_keypress (void *p
)
20730 int benchmark
= *((int *) p
);
20732 uint quiet
= data
.quiet
;
20736 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20738 int ch
= tty_getchar();
20740 if (ch
== -1) break;
20742 if (ch
== 0) continue;
20744 //https://github.com/hashcat/hashcat/issues/302
20749 hc_thread_mutex_lock (mux_display
);
20765 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20766 if (quiet
== 0) fflush (stdout
);
20778 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20779 if (quiet
== 0) fflush (stdout
);
20791 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20792 if (quiet
== 0) fflush (stdout
);
20804 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20805 if (quiet
== 0) fflush (stdout
);
20813 if (benchmark
== 1) break;
20815 stop_at_checkpoint ();
20819 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20820 if (quiet
== 0) fflush (stdout
);
20828 if (benchmark
== 1)
20840 //https://github.com/hashcat/hashcat/issues/302
20845 hc_thread_mutex_unlock (mux_display
);
20857 bool class_num (const u8 c
)
20859 return ((c
>= '0') && (c
<= '9'));
20862 bool class_lower (const u8 c
)
20864 return ((c
>= 'a') && (c
<= 'z'));
20867 bool class_upper (const u8 c
)
20869 return ((c
>= 'A') && (c
<= 'Z'));
20872 bool class_alpha (const u8 c
)
20874 return (class_lower (c
) || class_upper (c
));
20877 int conv_ctoi (const u8 c
)
20883 else if (class_upper (c
))
20885 return c
- 'A' + 10;
20891 int conv_itoc (const u8 c
)
20899 return c
+ 'A' - 10;
20909 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20910 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20911 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20912 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20913 #define MAX_KERNEL_RULES 255
20914 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20915 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20916 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20918 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20919 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20920 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20921 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20923 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20928 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20930 switch (rule_buf
[rule_pos
])
20936 case RULE_OP_MANGLE_NOOP
:
20937 SET_NAME (rule
, rule_buf
[rule_pos
]);
20940 case RULE_OP_MANGLE_LREST
:
20941 SET_NAME (rule
, rule_buf
[rule_pos
]);
20944 case RULE_OP_MANGLE_UREST
:
20945 SET_NAME (rule
, rule_buf
[rule_pos
]);
20948 case RULE_OP_MANGLE_LREST_UFIRST
:
20949 SET_NAME (rule
, rule_buf
[rule_pos
]);
20952 case RULE_OP_MANGLE_UREST_LFIRST
:
20953 SET_NAME (rule
, rule_buf
[rule_pos
]);
20956 case RULE_OP_MANGLE_TREST
:
20957 SET_NAME (rule
, rule_buf
[rule_pos
]);
20960 case RULE_OP_MANGLE_TOGGLE_AT
:
20961 SET_NAME (rule
, rule_buf
[rule_pos
]);
20962 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20965 case RULE_OP_MANGLE_REVERSE
:
20966 SET_NAME (rule
, rule_buf
[rule_pos
]);
20969 case RULE_OP_MANGLE_DUPEWORD
:
20970 SET_NAME (rule
, rule_buf
[rule_pos
]);
20973 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20974 SET_NAME (rule
, rule_buf
[rule_pos
]);
20975 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20978 case RULE_OP_MANGLE_REFLECT
:
20979 SET_NAME (rule
, rule_buf
[rule_pos
]);
20982 case RULE_OP_MANGLE_ROTATE_LEFT
:
20983 SET_NAME (rule
, rule_buf
[rule_pos
]);
20986 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20987 SET_NAME (rule
, rule_buf
[rule_pos
]);
20990 case RULE_OP_MANGLE_APPEND
:
20991 SET_NAME (rule
, rule_buf
[rule_pos
]);
20992 SET_P0 (rule
, rule_buf
[rule_pos
]);
20995 case RULE_OP_MANGLE_PREPEND
:
20996 SET_NAME (rule
, rule_buf
[rule_pos
]);
20997 SET_P0 (rule
, rule_buf
[rule_pos
]);
21000 case RULE_OP_MANGLE_DELETE_FIRST
:
21001 SET_NAME (rule
, rule_buf
[rule_pos
]);
21004 case RULE_OP_MANGLE_DELETE_LAST
:
21005 SET_NAME (rule
, rule_buf
[rule_pos
]);
21008 case RULE_OP_MANGLE_DELETE_AT
:
21009 SET_NAME (rule
, rule_buf
[rule_pos
]);
21010 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21013 case RULE_OP_MANGLE_EXTRACT
:
21014 SET_NAME (rule
, rule_buf
[rule_pos
]);
21015 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21016 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21019 case RULE_OP_MANGLE_OMIT
:
21020 SET_NAME (rule
, rule_buf
[rule_pos
]);
21021 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21022 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21025 case RULE_OP_MANGLE_INSERT
:
21026 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21028 SET_P1 (rule
, rule_buf
[rule_pos
]);
21031 case RULE_OP_MANGLE_OVERSTRIKE
:
21032 SET_NAME (rule
, rule_buf
[rule_pos
]);
21033 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21034 SET_P1 (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_TRUNCATE_AT
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21039 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21042 case RULE_OP_MANGLE_REPLACE
:
21043 SET_NAME (rule
, rule_buf
[rule_pos
]);
21044 SET_P0 (rule
, rule_buf
[rule_pos
]);
21045 SET_P1 (rule
, rule_buf
[rule_pos
]);
21048 case RULE_OP_MANGLE_PURGECHAR
:
21052 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21056 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21057 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21061 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21062 SET_NAME (rule
, rule_buf
[rule_pos
]);
21063 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21066 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21067 SET_NAME (rule
, rule_buf
[rule_pos
]);
21070 case RULE_OP_MANGLE_SWITCH_FIRST
:
21071 SET_NAME (rule
, rule_buf
[rule_pos
]);
21074 case RULE_OP_MANGLE_SWITCH_LAST
:
21075 SET_NAME (rule
, rule_buf
[rule_pos
]);
21078 case RULE_OP_MANGLE_SWITCH_AT
:
21079 SET_NAME (rule
, rule_buf
[rule_pos
]);
21080 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21081 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21084 case RULE_OP_MANGLE_CHR_SHIFTL
:
21085 SET_NAME (rule
, rule_buf
[rule_pos
]);
21086 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21089 case RULE_OP_MANGLE_CHR_SHIFTR
:
21090 SET_NAME (rule
, rule_buf
[rule_pos
]);
21091 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21094 case RULE_OP_MANGLE_CHR_INCR
:
21095 SET_NAME (rule
, rule_buf
[rule_pos
]);
21096 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21099 case RULE_OP_MANGLE_CHR_DECR
:
21100 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21104 case RULE_OP_MANGLE_REPLACE_NP1
:
21105 SET_NAME (rule
, rule_buf
[rule_pos
]);
21106 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21109 case RULE_OP_MANGLE_REPLACE_NM1
:
21110 SET_NAME (rule
, rule_buf
[rule_pos
]);
21111 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21114 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21115 SET_NAME (rule
, rule_buf
[rule_pos
]);
21116 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21119 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21120 SET_NAME (rule
, rule_buf
[rule_pos
]);
21121 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21124 case RULE_OP_MANGLE_TITLE
:
21125 SET_NAME (rule
, rule_buf
[rule_pos
]);
21134 if (rule_pos
< rule_len
) return (-1);
21139 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21143 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21147 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21151 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21155 case RULE_OP_MANGLE_NOOP
:
21156 rule_buf
[rule_pos
] = rule_cmd
;
21159 case RULE_OP_MANGLE_LREST
:
21160 rule_buf
[rule_pos
] = rule_cmd
;
21163 case RULE_OP_MANGLE_UREST
:
21164 rule_buf
[rule_pos
] = rule_cmd
;
21167 case RULE_OP_MANGLE_LREST_UFIRST
:
21168 rule_buf
[rule_pos
] = rule_cmd
;
21171 case RULE_OP_MANGLE_UREST_LFIRST
:
21172 rule_buf
[rule_pos
] = rule_cmd
;
21175 case RULE_OP_MANGLE_TREST
:
21176 rule_buf
[rule_pos
] = rule_cmd
;
21179 case RULE_OP_MANGLE_TOGGLE_AT
:
21180 rule_buf
[rule_pos
] = rule_cmd
;
21181 GET_P0_CONV (rule
);
21184 case RULE_OP_MANGLE_REVERSE
:
21185 rule_buf
[rule_pos
] = rule_cmd
;
21188 case RULE_OP_MANGLE_DUPEWORD
:
21189 rule_buf
[rule_pos
] = rule_cmd
;
21192 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21193 rule_buf
[rule_pos
] = rule_cmd
;
21194 GET_P0_CONV (rule
);
21197 case RULE_OP_MANGLE_REFLECT
:
21198 rule_buf
[rule_pos
] = rule_cmd
;
21201 case RULE_OP_MANGLE_ROTATE_LEFT
:
21202 rule_buf
[rule_pos
] = rule_cmd
;
21205 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21206 rule_buf
[rule_pos
] = rule_cmd
;
21209 case RULE_OP_MANGLE_APPEND
:
21210 rule_buf
[rule_pos
] = rule_cmd
;
21214 case RULE_OP_MANGLE_PREPEND
:
21215 rule_buf
[rule_pos
] = rule_cmd
;
21219 case RULE_OP_MANGLE_DELETE_FIRST
:
21220 rule_buf
[rule_pos
] = rule_cmd
;
21223 case RULE_OP_MANGLE_DELETE_LAST
:
21224 rule_buf
[rule_pos
] = rule_cmd
;
21227 case RULE_OP_MANGLE_DELETE_AT
:
21228 rule_buf
[rule_pos
] = rule_cmd
;
21229 GET_P0_CONV (rule
);
21232 case RULE_OP_MANGLE_EXTRACT
:
21233 rule_buf
[rule_pos
] = rule_cmd
;
21234 GET_P0_CONV (rule
);
21235 GET_P1_CONV (rule
);
21238 case RULE_OP_MANGLE_OMIT
:
21239 rule_buf
[rule_pos
] = rule_cmd
;
21240 GET_P0_CONV (rule
);
21241 GET_P1_CONV (rule
);
21244 case RULE_OP_MANGLE_INSERT
:
21245 rule_buf
[rule_pos
] = rule_cmd
;
21246 GET_P0_CONV (rule
);
21250 case RULE_OP_MANGLE_OVERSTRIKE
:
21251 rule_buf
[rule_pos
] = rule_cmd
;
21252 GET_P0_CONV (rule
);
21256 case RULE_OP_MANGLE_TRUNCATE_AT
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21258 GET_P0_CONV (rule
);
21261 case RULE_OP_MANGLE_REPLACE
:
21262 rule_buf
[rule_pos
] = rule_cmd
;
21267 case RULE_OP_MANGLE_PURGECHAR
:
21271 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21275 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21276 rule_buf
[rule_pos
] = rule_cmd
;
21277 GET_P0_CONV (rule
);
21280 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21281 rule_buf
[rule_pos
] = rule_cmd
;
21282 GET_P0_CONV (rule
);
21285 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21286 rule_buf
[rule_pos
] = rule_cmd
;
21289 case RULE_OP_MANGLE_SWITCH_FIRST
:
21290 rule_buf
[rule_pos
] = rule_cmd
;
21293 case RULE_OP_MANGLE_SWITCH_LAST
:
21294 rule_buf
[rule_pos
] = rule_cmd
;
21297 case RULE_OP_MANGLE_SWITCH_AT
:
21298 rule_buf
[rule_pos
] = rule_cmd
;
21299 GET_P0_CONV (rule
);
21300 GET_P1_CONV (rule
);
21303 case RULE_OP_MANGLE_CHR_SHIFTL
:
21304 rule_buf
[rule_pos
] = rule_cmd
;
21305 GET_P0_CONV (rule
);
21308 case RULE_OP_MANGLE_CHR_SHIFTR
:
21309 rule_buf
[rule_pos
] = rule_cmd
;
21310 GET_P0_CONV (rule
);
21313 case RULE_OP_MANGLE_CHR_INCR
:
21314 rule_buf
[rule_pos
] = rule_cmd
;
21315 GET_P0_CONV (rule
);
21318 case RULE_OP_MANGLE_CHR_DECR
:
21319 rule_buf
[rule_pos
] = rule_cmd
;
21320 GET_P0_CONV (rule
);
21323 case RULE_OP_MANGLE_REPLACE_NP1
:
21324 rule_buf
[rule_pos
] = rule_cmd
;
21325 GET_P0_CONV (rule
);
21328 case RULE_OP_MANGLE_REPLACE_NM1
:
21329 rule_buf
[rule_pos
] = rule_cmd
;
21330 GET_P0_CONV (rule
);
21333 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21334 rule_buf
[rule_pos
] = rule_cmd
;
21335 GET_P0_CONV (rule
);
21338 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21339 rule_buf
[rule_pos
] = rule_cmd
;
21340 GET_P0_CONV (rule
);
21343 case RULE_OP_MANGLE_TITLE
:
21344 rule_buf
[rule_pos
] = rule_cmd
;
21348 return rule_pos
- 1;
21366 * CPU rules : this is from hashcat sources, cpu based rules
21369 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21370 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21372 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21373 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21374 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21376 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21377 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21378 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21380 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21384 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21389 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21393 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21398 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21402 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21407 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21412 for (l
= 0; l
< arr_len
; l
++)
21414 r
= arr_len
- 1 - l
;
21418 MANGLE_SWITCH (arr
, l
, r
);
21424 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21426 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21428 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21430 return (arr_len
* 2);
21433 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21435 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21437 int orig_len
= arr_len
;
21441 for (i
= 0; i
< times
; i
++)
21443 memcpy (&arr
[arr_len
], arr
, orig_len
);
21445 arr_len
+= orig_len
;
21451 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21453 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21455 mangle_double (arr
, arr_len
);
21457 mangle_reverse (arr
+ arr_len
, arr_len
);
21459 return (arr_len
* 2);
21462 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21467 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21469 MANGLE_SWITCH (arr
, l
, r
);
21475 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21480 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21482 MANGLE_SWITCH (arr
, l
, r
);
21488 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21490 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21494 return (arr_len
+ 1);
21497 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21499 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21503 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21505 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21510 return (arr_len
+ 1);
21513 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21515 if (upos
>= arr_len
) return (arr_len
);
21519 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21521 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21524 return (arr_len
- 1);
21527 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21529 if (upos
>= arr_len
) return (arr_len
);
21531 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21535 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21537 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21543 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21545 if (upos
>= arr_len
) return (arr_len
);
21547 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21551 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21553 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21556 return (arr_len
- ulen
);
21559 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21561 if (upos
>= arr_len
) return (arr_len
);
21563 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21567 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21569 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21574 return (arr_len
+ 1);
21577 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
)
21579 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21581 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21583 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21585 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21587 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21589 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21591 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21593 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21595 return (arr_len
+ arr2_cpy
);
21598 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21600 if (upos
>= arr_len
) return (arr_len
);
21607 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21609 if (upos
>= arr_len
) return (arr_len
);
21611 memset (arr
+ upos
, 0, arr_len
- upos
);
21616 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21620 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21622 if (arr
[arr_pos
] != oldc
) continue;
21624 arr
[arr_pos
] = newc
;
21630 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21636 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21638 if (arr
[arr_pos
] == c
) continue;
21640 arr
[ret_len
] = arr
[arr_pos
];
21648 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21650 if (ulen
> arr_len
) return (arr_len
);
21652 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21654 char cs
[100] = { 0 };
21656 memcpy (cs
, arr
, ulen
);
21660 for (i
= 0; i
< ulen
; i
++)
21664 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21670 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21672 if (ulen
> arr_len
) return (arr_len
);
21674 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21676 int upos
= arr_len
- ulen
;
21680 for (i
= 0; i
< ulen
; i
++)
21682 char c
= arr
[upos
+ i
];
21684 arr_len
= mangle_append (arr
, arr_len
, c
);
21690 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21692 if ( arr_len
== 0) return (arr_len
);
21693 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21695 char c
= arr
[upos
];
21699 for (i
= 0; i
< ulen
; i
++)
21701 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21707 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21709 if ( arr_len
== 0) return (arr_len
);
21710 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21714 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21716 int new_pos
= arr_pos
* 2;
21718 arr
[new_pos
] = arr
[arr_pos
];
21720 arr
[new_pos
+ 1] = arr
[arr_pos
];
21723 return (arr_len
* 2);
21726 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21728 if (upos
>= arr_len
) return (arr_len
);
21729 if (upos2
>= arr_len
) return (arr_len
);
21731 MANGLE_SWITCH (arr
, upos
, upos2
);
21736 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21738 MANGLE_SWITCH (arr
, upos
, upos2
);
21743 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21745 if (upos
>= arr_len
) return (arr_len
);
21752 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21754 if (upos
>= arr_len
) return (arr_len
);
21761 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21763 if (upos
>= arr_len
) return (arr_len
);
21770 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21772 if (upos
>= arr_len
) return (arr_len
);
21779 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21781 int upper_next
= 1;
21785 for (pos
= 0; pos
< arr_len
; pos
++)
21787 if (arr
[pos
] == ' ')
21798 MANGLE_UPPER_AT (arr
, pos
);
21802 MANGLE_LOWER_AT (arr
, pos
);
21809 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21811 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21817 for (j
= 0; j
< rp_gen_num
; j
++)
21824 switch ((char) get_random_num (0, 9))
21827 r
= get_random_num (0, sizeof (grp_op_nop
));
21828 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21832 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21833 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21834 p1
= get_random_num (0, sizeof (grp_pos
));
21835 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21839 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21840 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21841 p1
= get_random_num (1, 6);
21842 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21846 r
= get_random_num (0, sizeof (grp_op_chr
));
21847 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21848 p1
= get_random_num (0x20, 0x7e);
21849 rule_buf
[rule_pos
++] = (char) p1
;
21853 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21854 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21855 p1
= get_random_num (0x20, 0x7e);
21856 rule_buf
[rule_pos
++] = (char) p1
;
21857 p2
= get_random_num (0x20, 0x7e);
21859 p2
= get_random_num (0x20, 0x7e);
21860 rule_buf
[rule_pos
++] = (char) p2
;
21864 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21865 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21866 p1
= get_random_num (0, sizeof (grp_pos
));
21867 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21868 p2
= get_random_num (0x20, 0x7e);
21869 rule_buf
[rule_pos
++] = (char) p2
;
21873 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21874 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21875 p1
= get_random_num (0, sizeof (grp_pos
));
21876 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21877 p2
= get_random_num (0, sizeof (grp_pos
));
21879 p2
= get_random_num (0, sizeof (grp_pos
));
21880 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21884 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21885 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21886 p1
= get_random_num (0, sizeof (grp_pos
));
21887 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21888 p2
= get_random_num (1, sizeof (grp_pos
));
21890 p2
= get_random_num (1, sizeof (grp_pos
));
21891 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21895 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21896 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21897 p1
= get_random_num (0, sizeof (grp_pos
));
21898 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21899 p2
= get_random_num (1, sizeof (grp_pos
));
21900 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21901 p3
= get_random_num (0, sizeof (grp_pos
));
21902 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21910 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21912 char mem
[BLOCK_SIZE
] = { 0 };
21914 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21916 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21918 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21920 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21922 int out_len
= in_len
;
21923 int mem_len
= in_len
;
21925 memcpy (out
, in
, out_len
);
21929 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21934 switch (rule
[rule_pos
])
21939 case RULE_OP_MANGLE_NOOP
:
21942 case RULE_OP_MANGLE_LREST
:
21943 out_len
= mangle_lrest (out
, out_len
);
21946 case RULE_OP_MANGLE_UREST
:
21947 out_len
= mangle_urest (out
, out_len
);
21950 case RULE_OP_MANGLE_LREST_UFIRST
:
21951 out_len
= mangle_lrest (out
, out_len
);
21952 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21955 case RULE_OP_MANGLE_UREST_LFIRST
:
21956 out_len
= mangle_urest (out
, out_len
);
21957 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21960 case RULE_OP_MANGLE_TREST
:
21961 out_len
= mangle_trest (out
, out_len
);
21964 case RULE_OP_MANGLE_TOGGLE_AT
:
21965 NEXT_RULEPOS (rule_pos
);
21966 NEXT_RPTOI (rule
, rule_pos
, upos
);
21967 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21970 case RULE_OP_MANGLE_REVERSE
:
21971 out_len
= mangle_reverse (out
, out_len
);
21974 case RULE_OP_MANGLE_DUPEWORD
:
21975 out_len
= mangle_double (out
, out_len
);
21978 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21979 NEXT_RULEPOS (rule_pos
);
21980 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21981 out_len
= mangle_double_times (out
, out_len
, ulen
);
21984 case RULE_OP_MANGLE_REFLECT
:
21985 out_len
= mangle_reflect (out
, out_len
);
21988 case RULE_OP_MANGLE_ROTATE_LEFT
:
21989 mangle_rotate_left (out
, out_len
);
21992 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21993 mangle_rotate_right (out
, out_len
);
21996 case RULE_OP_MANGLE_APPEND
:
21997 NEXT_RULEPOS (rule_pos
);
21998 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22001 case RULE_OP_MANGLE_PREPEND
:
22002 NEXT_RULEPOS (rule_pos
);
22003 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22006 case RULE_OP_MANGLE_DELETE_FIRST
:
22007 out_len
= mangle_delete_at (out
, out_len
, 0);
22010 case RULE_OP_MANGLE_DELETE_LAST
:
22011 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22014 case RULE_OP_MANGLE_DELETE_AT
:
22015 NEXT_RULEPOS (rule_pos
);
22016 NEXT_RPTOI (rule
, rule_pos
, upos
);
22017 out_len
= mangle_delete_at (out
, out_len
, upos
);
22020 case RULE_OP_MANGLE_EXTRACT
:
22021 NEXT_RULEPOS (rule_pos
);
22022 NEXT_RPTOI (rule
, rule_pos
, upos
);
22023 NEXT_RULEPOS (rule_pos
);
22024 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22025 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22028 case RULE_OP_MANGLE_OMIT
:
22029 NEXT_RULEPOS (rule_pos
);
22030 NEXT_RPTOI (rule
, rule_pos
, upos
);
22031 NEXT_RULEPOS (rule_pos
);
22032 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22033 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22036 case RULE_OP_MANGLE_INSERT
:
22037 NEXT_RULEPOS (rule_pos
);
22038 NEXT_RPTOI (rule
, rule_pos
, upos
);
22039 NEXT_RULEPOS (rule_pos
);
22040 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22043 case RULE_OP_MANGLE_OVERSTRIKE
:
22044 NEXT_RULEPOS (rule_pos
);
22045 NEXT_RPTOI (rule
, rule_pos
, upos
);
22046 NEXT_RULEPOS (rule_pos
);
22047 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22050 case RULE_OP_MANGLE_TRUNCATE_AT
:
22051 NEXT_RULEPOS (rule_pos
);
22052 NEXT_RPTOI (rule
, rule_pos
, upos
);
22053 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22056 case RULE_OP_MANGLE_REPLACE
:
22057 NEXT_RULEPOS (rule_pos
);
22058 NEXT_RULEPOS (rule_pos
);
22059 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22062 case RULE_OP_MANGLE_PURGECHAR
:
22063 NEXT_RULEPOS (rule_pos
);
22064 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22067 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22071 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22072 NEXT_RULEPOS (rule_pos
);
22073 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22074 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22077 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22078 NEXT_RULEPOS (rule_pos
);
22079 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22080 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22083 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22084 out_len
= mangle_dupechar (out
, out_len
);
22087 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22088 NEXT_RULEPOS (rule_pos
);
22089 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22090 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22093 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22094 NEXT_RULEPOS (rule_pos
);
22095 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22096 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22099 case RULE_OP_MANGLE_SWITCH_FIRST
:
22100 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22103 case RULE_OP_MANGLE_SWITCH_LAST
:
22104 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22107 case RULE_OP_MANGLE_SWITCH_AT
:
22108 NEXT_RULEPOS (rule_pos
);
22109 NEXT_RPTOI (rule
, rule_pos
, upos
);
22110 NEXT_RULEPOS (rule_pos
);
22111 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22112 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22115 case RULE_OP_MANGLE_CHR_SHIFTL
:
22116 NEXT_RULEPOS (rule_pos
);
22117 NEXT_RPTOI (rule
, rule_pos
, upos
);
22118 mangle_chr_shiftl (out
, out_len
, upos
);
22121 case RULE_OP_MANGLE_CHR_SHIFTR
:
22122 NEXT_RULEPOS (rule_pos
);
22123 NEXT_RPTOI (rule
, rule_pos
, upos
);
22124 mangle_chr_shiftr (out
, out_len
, upos
);
22127 case RULE_OP_MANGLE_CHR_INCR
:
22128 NEXT_RULEPOS (rule_pos
);
22129 NEXT_RPTOI (rule
, rule_pos
, upos
);
22130 mangle_chr_incr (out
, out_len
, upos
);
22133 case RULE_OP_MANGLE_CHR_DECR
:
22134 NEXT_RULEPOS (rule_pos
);
22135 NEXT_RPTOI (rule
, rule_pos
, upos
);
22136 mangle_chr_decr (out
, out_len
, upos
);
22139 case RULE_OP_MANGLE_REPLACE_NP1
:
22140 NEXT_RULEPOS (rule_pos
);
22141 NEXT_RPTOI (rule
, rule_pos
, upos
);
22142 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22145 case RULE_OP_MANGLE_REPLACE_NM1
:
22146 NEXT_RULEPOS (rule_pos
);
22147 NEXT_RPTOI (rule
, rule_pos
, upos
);
22148 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22151 case RULE_OP_MANGLE_TITLE
:
22152 out_len
= mangle_title (out
, out_len
);
22155 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22156 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22157 NEXT_RULEPOS (rule_pos
);
22158 NEXT_RPTOI (rule
, rule_pos
, upos
);
22159 NEXT_RULEPOS (rule_pos
);
22160 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22161 NEXT_RULEPOS (rule_pos
);
22162 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22163 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22166 case RULE_OP_MANGLE_APPEND_MEMORY
:
22167 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22168 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22169 memcpy (out
+ out_len
, mem
, mem_len
);
22170 out_len
+= mem_len
;
22173 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22174 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22175 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22176 memcpy (mem
+ mem_len
, out
, out_len
);
22177 out_len
+= mem_len
;
22178 memcpy (out
, mem
, out_len
);
22181 case RULE_OP_MEMORIZE_WORD
:
22182 memcpy (mem
, out
, out_len
);
22186 case RULE_OP_REJECT_LESS
:
22187 NEXT_RULEPOS (rule_pos
);
22188 NEXT_RPTOI (rule
, rule_pos
, upos
);
22189 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22192 case RULE_OP_REJECT_GREATER
:
22193 NEXT_RULEPOS (rule_pos
);
22194 NEXT_RPTOI (rule
, rule_pos
, upos
);
22195 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22198 case RULE_OP_REJECT_CONTAIN
:
22199 NEXT_RULEPOS (rule_pos
);
22200 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22203 case RULE_OP_REJECT_NOT_CONTAIN
:
22204 NEXT_RULEPOS (rule_pos
);
22205 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22208 case RULE_OP_REJECT_EQUAL_FIRST
:
22209 NEXT_RULEPOS (rule_pos
);
22210 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22213 case RULE_OP_REJECT_EQUAL_LAST
:
22214 NEXT_RULEPOS (rule_pos
);
22215 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22218 case RULE_OP_REJECT_EQUAL_AT
:
22219 NEXT_RULEPOS (rule_pos
);
22220 NEXT_RPTOI (rule
, rule_pos
, upos
);
22221 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22222 NEXT_RULEPOS (rule_pos
);
22223 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22226 case RULE_OP_REJECT_CONTAINS
:
22227 NEXT_RULEPOS (rule_pos
);
22228 NEXT_RPTOI (rule
, rule_pos
, upos
);
22229 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22230 NEXT_RULEPOS (rule_pos
);
22231 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22232 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22235 case RULE_OP_REJECT_MEMORY
:
22236 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22240 return (RULE_RC_SYNTAX_ERROR
);
22245 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);