2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
117 int log_out_nn (FILE *fp
, const char *fmt
, ...)
119 if (SUPPRESS_OUTPUT
) return 0;
125 const int len
= log_final (fp
, fmt
, ap
);
132 int log_info_nn (const char *fmt
, ...)
134 if (SUPPRESS_OUTPUT
) return 0;
140 const int len
= log_final (stdout
, fmt
, ap
);
147 int log_error_nn (const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return 0;
155 const int len
= log_final (stderr
, fmt
, ap
);
162 int log_out (FILE *fp
, const char *fmt
, ...)
164 if (SUPPRESS_OUTPUT
) return 0;
170 const int len
= log_final (fp
, fmt
, ap
);
181 int log_info (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return 0;
189 const int len
= log_final (stdout
, fmt
, ap
);
193 fputc ('\n', stdout
);
200 int log_error (const char *fmt
, ...)
202 if (SUPPRESS_OUTPUT
) return 0;
204 fputc ('\n', stderr
);
205 fputc ('\n', stderr
);
211 const int len
= log_final (stderr
, fmt
, ap
);
215 fputc ('\n', stderr
);
216 fputc ('\n', stderr
);
227 u8
int_to_base32 (const u8 c
)
229 static const u8 tbl
[0x20] =
231 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
232 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
238 u8
base32_to_int (const u8 c
)
240 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
241 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
246 u8
int_to_itoa32 (const u8 c
)
248 static const u8 tbl
[0x20] =
250 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
251 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
257 u8
itoa32_to_int (const u8 c
)
259 if ((c
>= '0') && (c
<= '9')) return c
- '0';
260 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
265 u8
int_to_itoa64 (const u8 c
)
267 static const u8 tbl
[0x40] =
269 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
270 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
271 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
272 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
278 u8
itoa64_to_int (const u8 c
)
280 static const u8 tbl
[0x100] =
282 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
283 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
284 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
285 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
286 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
287 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
288 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
289 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
290 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
291 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
292 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
293 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
294 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
295 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
296 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
297 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
303 u8
int_to_base64 (const u8 c
)
305 static const u8 tbl
[0x40] =
307 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
308 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
309 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
310 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
316 u8
base64_to_int (const u8 c
)
318 static const u8 tbl
[0x100] =
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
323 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
327 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 u8
int_to_bf64 (const u8 c
)
343 static const u8 tbl
[0x40] =
345 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
346 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
347 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
348 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
354 u8
bf64_to_int (const u8 c
)
356 static const u8 tbl
[0x100] =
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
361 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
363 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
365 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 u8
int_to_lotus64 (const u8 c
)
381 if (c
< 10) return '0' + c
;
382 else if (c
< 36) return 'A' + c
- 10;
383 else if (c
< 62) return 'a' + c
- 36;
384 else if (c
== 62) return '+';
385 else if (c
== 63) return '/';
390 u8
lotus64_to_int (const u8 c
)
392 if ((c
>= '0') && (c
<= '9')) return c
- '0';
393 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
394 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
395 else if (c
== '+') return 62;
396 else if (c
== '/') return 63;
402 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
404 const u8
*in_ptr
= in_buf
;
406 u8
*out_ptr
= out_buf
;
408 for (int i
= 0; i
< in_len
; i
+= 8)
410 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
411 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
412 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
413 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
414 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
415 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
416 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
417 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
419 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
420 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
421 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
422 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
423 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
429 for (int i
= 0; i
< in_len
; i
++)
431 if (in_buf
[i
] != '=') continue;
436 int out_len
= (in_len
* 5) / 8;
441 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
443 const u8
*in_ptr
= in_buf
;
445 u8
*out_ptr
= out_buf
;
447 for (int i
= 0; i
< in_len
; i
+= 5)
449 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
450 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
451 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
452 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
453 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
454 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
455 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
456 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
458 out_ptr
[0] = out_val0
& 0x7f;
459 out_ptr
[1] = out_val1
& 0x7f;
460 out_ptr
[2] = out_val2
& 0x7f;
461 out_ptr
[3] = out_val3
& 0x7f;
462 out_ptr
[4] = out_val4
& 0x7f;
463 out_ptr
[5] = out_val5
& 0x7f;
464 out_ptr
[6] = out_val6
& 0x7f;
465 out_ptr
[7] = out_val7
& 0x7f;
471 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
475 out_buf
[out_len
] = '=';
483 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
485 const u8
*in_ptr
= in_buf
;
487 u8
*out_ptr
= out_buf
;
489 for (int i
= 0; i
< in_len
; i
+= 4)
491 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
492 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
493 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
494 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
496 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
497 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
498 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
504 for (int i
= 0; i
< in_len
; i
++)
506 if (in_buf
[i
] != '=') continue;
511 int out_len
= (in_len
* 6) / 8;
516 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
518 const u8
*in_ptr
= in_buf
;
520 u8
*out_ptr
= out_buf
;
522 for (int i
= 0; i
< in_len
; i
+= 3)
524 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
525 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
526 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
527 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
529 out_ptr
[0] = out_val0
& 0x7f;
530 out_ptr
[1] = out_val1
& 0x7f;
531 out_ptr
[2] = out_val2
& 0x7f;
532 out_ptr
[3] = out_val3
& 0x7f;
538 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
542 out_buf
[out_len
] = '=';
550 int is_valid_hex_char (const u8 c
)
552 if ((c
>= '0') && (c
<= '9')) return 1;
553 if ((c
>= 'A') && (c
<= 'F')) return 1;
554 if ((c
>= 'a') && (c
<= 'f')) return 1;
559 u8
hex_convert (const u8 c
)
561 return (c
& 15) + (c
>> 6) * 9;
564 u8
hex_to_u8 (const u8 hex
[2])
568 v
|= (hex_convert (hex
[1]) << 0);
569 v
|= (hex_convert (hex
[0]) << 4);
574 u32
hex_to_u32 (const u8 hex
[8])
578 v
|= ((u32
) hex_convert (hex
[7])) << 0;
579 v
|= ((u32
) hex_convert (hex
[6])) << 4;
580 v
|= ((u32
) hex_convert (hex
[5])) << 8;
581 v
|= ((u32
) hex_convert (hex
[4])) << 12;
582 v
|= ((u32
) hex_convert (hex
[3])) << 16;
583 v
|= ((u32
) hex_convert (hex
[2])) << 20;
584 v
|= ((u32
) hex_convert (hex
[1])) << 24;
585 v
|= ((u32
) hex_convert (hex
[0])) << 28;
590 u64
hex_to_u64 (const u8 hex
[16])
594 v
|= ((u64
) hex_convert (hex
[15]) << 0);
595 v
|= ((u64
) hex_convert (hex
[14]) << 4);
596 v
|= ((u64
) hex_convert (hex
[13]) << 8);
597 v
|= ((u64
) hex_convert (hex
[12]) << 12);
598 v
|= ((u64
) hex_convert (hex
[11]) << 16);
599 v
|= ((u64
) hex_convert (hex
[10]) << 20);
600 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
601 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
602 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
603 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
604 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
605 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
606 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
607 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
608 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
609 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
614 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
616 hex
[0] = v
>> 28 & 15;
617 hex
[1] = v
>> 24 & 15;
618 hex
[2] = v
>> 20 & 15;
619 hex
[3] = v
>> 16 & 15;
620 hex
[4] = v
>> 12 & 15;
621 hex
[5] = v
>> 8 & 15;
622 hex
[6] = v
>> 4 & 15;
623 hex
[7] = v
>> 0 & 15;
627 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
628 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
629 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
630 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
631 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
632 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
633 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
634 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
641 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
645 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
654 for (int i
= 0; i
< 16; i
+= 4)
664 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
671 out
[i
+ 0] = _out
[0];
672 out
[i
+ 1] = _out
[1];
673 out
[i
+ 2] = _out
[2];
674 out
[i
+ 3] = _out
[3];
683 static void juniper_decrypt_hash (char *in
, char *out
)
687 u8 base64_buf
[100] = { 0 };
689 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
693 u32 juniper_iv
[4] = { 0 };
695 memcpy (juniper_iv
, base64_buf
, 12);
697 memcpy (out
, juniper_iv
, 12);
701 u32 juniper_key
[4] = { 0 };
703 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
704 juniper_key
[1] = byte_swap_32 (0x8df91059);
705 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
706 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
710 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
711 u32
*out_ptr
= (u32
*) (out
+ 12);
713 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
716 void phpass_decode (u8 digest
[16], u8 buf
[22])
720 l
= itoa64_to_int (buf
[ 0]) << 0;
721 l
|= itoa64_to_int (buf
[ 1]) << 6;
722 l
|= itoa64_to_int (buf
[ 2]) << 12;
723 l
|= itoa64_to_int (buf
[ 3]) << 18;
725 digest
[ 0] = (l
>> 0) & 0xff;
726 digest
[ 1] = (l
>> 8) & 0xff;
727 digest
[ 2] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[ 4]) << 0;
730 l
|= itoa64_to_int (buf
[ 5]) << 6;
731 l
|= itoa64_to_int (buf
[ 6]) << 12;
732 l
|= itoa64_to_int (buf
[ 7]) << 18;
734 digest
[ 3] = (l
>> 0) & 0xff;
735 digest
[ 4] = (l
>> 8) & 0xff;
736 digest
[ 5] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[ 8]) << 0;
739 l
|= itoa64_to_int (buf
[ 9]) << 6;
740 l
|= itoa64_to_int (buf
[10]) << 12;
741 l
|= itoa64_to_int (buf
[11]) << 18;
743 digest
[ 6] = (l
>> 0) & 0xff;
744 digest
[ 7] = (l
>> 8) & 0xff;
745 digest
[ 8] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[12]) << 0;
748 l
|= itoa64_to_int (buf
[13]) << 6;
749 l
|= itoa64_to_int (buf
[14]) << 12;
750 l
|= itoa64_to_int (buf
[15]) << 18;
752 digest
[ 9] = (l
>> 0) & 0xff;
753 digest
[10] = (l
>> 8) & 0xff;
754 digest
[11] = (l
>> 16) & 0xff;
756 l
= itoa64_to_int (buf
[16]) << 0;
757 l
|= itoa64_to_int (buf
[17]) << 6;
758 l
|= itoa64_to_int (buf
[18]) << 12;
759 l
|= itoa64_to_int (buf
[19]) << 18;
761 digest
[12] = (l
>> 0) & 0xff;
762 digest
[13] = (l
>> 8) & 0xff;
763 digest
[14] = (l
>> 16) & 0xff;
765 l
= itoa64_to_int (buf
[20]) << 0;
766 l
|= itoa64_to_int (buf
[21]) << 6;
768 digest
[15] = (l
>> 0) & 0xff;
771 void phpass_encode (u8 digest
[16], u8 buf
[22])
775 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
777 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
784 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
791 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[11] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
798 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
800 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[15] = int_to_itoa64 (l
& 0x3f);
803 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
805 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
807 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
808 buf
[19] = int_to_itoa64 (l
& 0x3f);
810 l
= (digest
[15] << 0);
812 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[21] = int_to_itoa64 (l
& 0x3f);
816 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
820 l
= itoa64_to_int (buf
[ 0]) << 0;
821 l
|= itoa64_to_int (buf
[ 1]) << 6;
822 l
|= itoa64_to_int (buf
[ 2]) << 12;
823 l
|= itoa64_to_int (buf
[ 3]) << 18;
825 digest
[ 0] = (l
>> 16) & 0xff;
826 digest
[ 6] = (l
>> 8) & 0xff;
827 digest
[12] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[ 4]) << 0;
830 l
|= itoa64_to_int (buf
[ 5]) << 6;
831 l
|= itoa64_to_int (buf
[ 6]) << 12;
832 l
|= itoa64_to_int (buf
[ 7]) << 18;
834 digest
[ 1] = (l
>> 16) & 0xff;
835 digest
[ 7] = (l
>> 8) & 0xff;
836 digest
[13] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[ 8]) << 0;
839 l
|= itoa64_to_int (buf
[ 9]) << 6;
840 l
|= itoa64_to_int (buf
[10]) << 12;
841 l
|= itoa64_to_int (buf
[11]) << 18;
843 digest
[ 2] = (l
>> 16) & 0xff;
844 digest
[ 8] = (l
>> 8) & 0xff;
845 digest
[14] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[12]) << 0;
848 l
|= itoa64_to_int (buf
[13]) << 6;
849 l
|= itoa64_to_int (buf
[14]) << 12;
850 l
|= itoa64_to_int (buf
[15]) << 18;
852 digest
[ 3] = (l
>> 16) & 0xff;
853 digest
[ 9] = (l
>> 8) & 0xff;
854 digest
[15] = (l
>> 0) & 0xff;
856 l
= itoa64_to_int (buf
[16]) << 0;
857 l
|= itoa64_to_int (buf
[17]) << 6;
858 l
|= itoa64_to_int (buf
[18]) << 12;
859 l
|= itoa64_to_int (buf
[19]) << 18;
861 digest
[ 4] = (l
>> 16) & 0xff;
862 digest
[10] = (l
>> 8) & 0xff;
863 digest
[ 5] = (l
>> 0) & 0xff;
865 l
= itoa64_to_int (buf
[20]) << 0;
866 l
|= itoa64_to_int (buf
[21]) << 6;
868 digest
[11] = (l
>> 0) & 0xff;
871 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
875 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
877 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
884 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
891 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
898 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
900 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
903 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
905 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
907 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
910 l
= (digest
[11] << 0);
912 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
916 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
920 l
= itoa64_to_int (buf
[ 0]) << 0;
921 l
|= itoa64_to_int (buf
[ 1]) << 6;
922 l
|= itoa64_to_int (buf
[ 2]) << 12;
923 l
|= itoa64_to_int (buf
[ 3]) << 18;
925 digest
[ 0] = (l
>> 16) & 0xff;
926 digest
[21] = (l
>> 8) & 0xff;
927 digest
[42] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[ 4]) << 0;
930 l
|= itoa64_to_int (buf
[ 5]) << 6;
931 l
|= itoa64_to_int (buf
[ 6]) << 12;
932 l
|= itoa64_to_int (buf
[ 7]) << 18;
934 digest
[22] = (l
>> 16) & 0xff;
935 digest
[43] = (l
>> 8) & 0xff;
936 digest
[ 1] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[ 8]) << 0;
939 l
|= itoa64_to_int (buf
[ 9]) << 6;
940 l
|= itoa64_to_int (buf
[10]) << 12;
941 l
|= itoa64_to_int (buf
[11]) << 18;
943 digest
[44] = (l
>> 16) & 0xff;
944 digest
[ 2] = (l
>> 8) & 0xff;
945 digest
[23] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[12]) << 0;
948 l
|= itoa64_to_int (buf
[13]) << 6;
949 l
|= itoa64_to_int (buf
[14]) << 12;
950 l
|= itoa64_to_int (buf
[15]) << 18;
952 digest
[ 3] = (l
>> 16) & 0xff;
953 digest
[24] = (l
>> 8) & 0xff;
954 digest
[45] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[16]) << 0;
957 l
|= itoa64_to_int (buf
[17]) << 6;
958 l
|= itoa64_to_int (buf
[18]) << 12;
959 l
|= itoa64_to_int (buf
[19]) << 18;
961 digest
[25] = (l
>> 16) & 0xff;
962 digest
[46] = (l
>> 8) & 0xff;
963 digest
[ 4] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[20]) << 0;
966 l
|= itoa64_to_int (buf
[21]) << 6;
967 l
|= itoa64_to_int (buf
[22]) << 12;
968 l
|= itoa64_to_int (buf
[23]) << 18;
970 digest
[47] = (l
>> 16) & 0xff;
971 digest
[ 5] = (l
>> 8) & 0xff;
972 digest
[26] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[24]) << 0;
975 l
|= itoa64_to_int (buf
[25]) << 6;
976 l
|= itoa64_to_int (buf
[26]) << 12;
977 l
|= itoa64_to_int (buf
[27]) << 18;
979 digest
[ 6] = (l
>> 16) & 0xff;
980 digest
[27] = (l
>> 8) & 0xff;
981 digest
[48] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[28]) << 0;
984 l
|= itoa64_to_int (buf
[29]) << 6;
985 l
|= itoa64_to_int (buf
[30]) << 12;
986 l
|= itoa64_to_int (buf
[31]) << 18;
988 digest
[28] = (l
>> 16) & 0xff;
989 digest
[49] = (l
>> 8) & 0xff;
990 digest
[ 7] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[32]) << 0;
993 l
|= itoa64_to_int (buf
[33]) << 6;
994 l
|= itoa64_to_int (buf
[34]) << 12;
995 l
|= itoa64_to_int (buf
[35]) << 18;
997 digest
[50] = (l
>> 16) & 0xff;
998 digest
[ 8] = (l
>> 8) & 0xff;
999 digest
[29] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[36]) << 0;
1002 l
|= itoa64_to_int (buf
[37]) << 6;
1003 l
|= itoa64_to_int (buf
[38]) << 12;
1004 l
|= itoa64_to_int (buf
[39]) << 18;
1006 digest
[ 9] = (l
>> 16) & 0xff;
1007 digest
[30] = (l
>> 8) & 0xff;
1008 digest
[51] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[40]) << 0;
1011 l
|= itoa64_to_int (buf
[41]) << 6;
1012 l
|= itoa64_to_int (buf
[42]) << 12;
1013 l
|= itoa64_to_int (buf
[43]) << 18;
1015 digest
[31] = (l
>> 16) & 0xff;
1016 digest
[52] = (l
>> 8) & 0xff;
1017 digest
[10] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[44]) << 0;
1020 l
|= itoa64_to_int (buf
[45]) << 6;
1021 l
|= itoa64_to_int (buf
[46]) << 12;
1022 l
|= itoa64_to_int (buf
[47]) << 18;
1024 digest
[53] = (l
>> 16) & 0xff;
1025 digest
[11] = (l
>> 8) & 0xff;
1026 digest
[32] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[48]) << 0;
1029 l
|= itoa64_to_int (buf
[49]) << 6;
1030 l
|= itoa64_to_int (buf
[50]) << 12;
1031 l
|= itoa64_to_int (buf
[51]) << 18;
1033 digest
[12] = (l
>> 16) & 0xff;
1034 digest
[33] = (l
>> 8) & 0xff;
1035 digest
[54] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[52]) << 0;
1038 l
|= itoa64_to_int (buf
[53]) << 6;
1039 l
|= itoa64_to_int (buf
[54]) << 12;
1040 l
|= itoa64_to_int (buf
[55]) << 18;
1042 digest
[34] = (l
>> 16) & 0xff;
1043 digest
[55] = (l
>> 8) & 0xff;
1044 digest
[13] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[56]) << 0;
1047 l
|= itoa64_to_int (buf
[57]) << 6;
1048 l
|= itoa64_to_int (buf
[58]) << 12;
1049 l
|= itoa64_to_int (buf
[59]) << 18;
1051 digest
[56] = (l
>> 16) & 0xff;
1052 digest
[14] = (l
>> 8) & 0xff;
1053 digest
[35] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[60]) << 0;
1056 l
|= itoa64_to_int (buf
[61]) << 6;
1057 l
|= itoa64_to_int (buf
[62]) << 12;
1058 l
|= itoa64_to_int (buf
[63]) << 18;
1060 digest
[15] = (l
>> 16) & 0xff;
1061 digest
[36] = (l
>> 8) & 0xff;
1062 digest
[57] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[64]) << 0;
1065 l
|= itoa64_to_int (buf
[65]) << 6;
1066 l
|= itoa64_to_int (buf
[66]) << 12;
1067 l
|= itoa64_to_int (buf
[67]) << 18;
1069 digest
[37] = (l
>> 16) & 0xff;
1070 digest
[58] = (l
>> 8) & 0xff;
1071 digest
[16] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[68]) << 0;
1074 l
|= itoa64_to_int (buf
[69]) << 6;
1075 l
|= itoa64_to_int (buf
[70]) << 12;
1076 l
|= itoa64_to_int (buf
[71]) << 18;
1078 digest
[59] = (l
>> 16) & 0xff;
1079 digest
[17] = (l
>> 8) & 0xff;
1080 digest
[38] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[72]) << 0;
1083 l
|= itoa64_to_int (buf
[73]) << 6;
1084 l
|= itoa64_to_int (buf
[74]) << 12;
1085 l
|= itoa64_to_int (buf
[75]) << 18;
1087 digest
[18] = (l
>> 16) & 0xff;
1088 digest
[39] = (l
>> 8) & 0xff;
1089 digest
[60] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[76]) << 0;
1092 l
|= itoa64_to_int (buf
[77]) << 6;
1093 l
|= itoa64_to_int (buf
[78]) << 12;
1094 l
|= itoa64_to_int (buf
[79]) << 18;
1096 digest
[40] = (l
>> 16) & 0xff;
1097 digest
[61] = (l
>> 8) & 0xff;
1098 digest
[19] = (l
>> 0) & 0xff;
1100 l
= itoa64_to_int (buf
[80]) << 0;
1101 l
|= itoa64_to_int (buf
[81]) << 6;
1102 l
|= itoa64_to_int (buf
[82]) << 12;
1103 l
|= itoa64_to_int (buf
[83]) << 18;
1105 digest
[62] = (l
>> 16) & 0xff;
1106 digest
[20] = (l
>> 8) & 0xff;
1107 digest
[41] = (l
>> 0) & 0xff;
1109 l
= itoa64_to_int (buf
[84]) << 0;
1110 l
|= itoa64_to_int (buf
[85]) << 6;
1112 digest
[63] = (l
>> 0) & 0xff;
1115 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1119 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1121 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1128 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1135 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1142 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1149 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1156 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1163 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1170 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1177 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1184 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1191 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1198 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1205 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1212 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1219 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1226 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1233 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1240 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1247 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1254 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1256 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1259 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1261 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1263 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1266 l
= 0 | 0 | (digest
[63] << 0);
1268 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1272 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1276 l
= itoa64_to_int (buf
[ 0]) << 0;
1277 l
|= itoa64_to_int (buf
[ 1]) << 6;
1278 l
|= itoa64_to_int (buf
[ 2]) << 12;
1279 l
|= itoa64_to_int (buf
[ 3]) << 18;
1281 digest
[ 2] = (l
>> 0) & 0xff;
1282 digest
[ 1] = (l
>> 8) & 0xff;
1283 digest
[ 0] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[ 4]) << 0;
1286 l
|= itoa64_to_int (buf
[ 5]) << 6;
1287 l
|= itoa64_to_int (buf
[ 6]) << 12;
1288 l
|= itoa64_to_int (buf
[ 7]) << 18;
1290 digest
[ 5] = (l
>> 0) & 0xff;
1291 digest
[ 4] = (l
>> 8) & 0xff;
1292 digest
[ 3] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[ 8]) << 0;
1295 l
|= itoa64_to_int (buf
[ 9]) << 6;
1296 l
|= itoa64_to_int (buf
[10]) << 12;
1297 l
|= itoa64_to_int (buf
[11]) << 18;
1299 digest
[ 8] = (l
>> 0) & 0xff;
1300 digest
[ 7] = (l
>> 8) & 0xff;
1301 digest
[ 6] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[12]) << 0;
1304 l
|= itoa64_to_int (buf
[13]) << 6;
1305 l
|= itoa64_to_int (buf
[14]) << 12;
1306 l
|= itoa64_to_int (buf
[15]) << 18;
1308 digest
[11] = (l
>> 0) & 0xff;
1309 digest
[10] = (l
>> 8) & 0xff;
1310 digest
[ 9] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[16]) << 0;
1313 l
|= itoa64_to_int (buf
[17]) << 6;
1314 l
|= itoa64_to_int (buf
[18]) << 12;
1315 l
|= itoa64_to_int (buf
[19]) << 18;
1317 digest
[14] = (l
>> 0) & 0xff;
1318 digest
[13] = (l
>> 8) & 0xff;
1319 digest
[12] = (l
>> 16) & 0xff;
1321 l
= itoa64_to_int (buf
[20]) << 0;
1322 l
|= itoa64_to_int (buf
[21]) << 6;
1323 l
|= itoa64_to_int (buf
[22]) << 12;
1324 l
|= itoa64_to_int (buf
[23]) << 18;
1326 digest
[17] = (l
>> 0) & 0xff;
1327 digest
[16] = (l
>> 8) & 0xff;
1328 digest
[15] = (l
>> 16) & 0xff;
1330 l
= itoa64_to_int (buf
[24]) << 0;
1331 l
|= itoa64_to_int (buf
[25]) << 6;
1332 l
|= itoa64_to_int (buf
[26]) << 12;
1334 digest
[19] = (l
>> 8) & 0xff;
1335 digest
[18] = (l
>> 16) & 0xff;
1338 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1342 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1344 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1351 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1358 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[11] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1365 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[15] = int_to_itoa64 (l
& 0x3f);
1370 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1372 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[19] = int_to_itoa64 (l
& 0x3f);
1377 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1379 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1381 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1382 buf
[23] = int_to_itoa64 (l
& 0x3f);
1384 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1386 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1388 buf
[26] = int_to_itoa64 (l
& 0x3f);
1391 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1395 l
= itoa64_to_int (buf
[ 0]) << 0;
1396 l
|= itoa64_to_int (buf
[ 1]) << 6;
1397 l
|= itoa64_to_int (buf
[ 2]) << 12;
1398 l
|= itoa64_to_int (buf
[ 3]) << 18;
1400 digest
[ 2] = (l
>> 0) & 0xff;
1401 digest
[ 1] = (l
>> 8) & 0xff;
1402 digest
[ 0] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[ 4]) << 0;
1405 l
|= itoa64_to_int (buf
[ 5]) << 6;
1406 l
|= itoa64_to_int (buf
[ 6]) << 12;
1407 l
|= itoa64_to_int (buf
[ 7]) << 18;
1409 digest
[ 5] = (l
>> 0) & 0xff;
1410 digest
[ 4] = (l
>> 8) & 0xff;
1411 digest
[ 3] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[ 8]) << 0;
1414 l
|= itoa64_to_int (buf
[ 9]) << 6;
1415 l
|= itoa64_to_int (buf
[10]) << 12;
1416 l
|= itoa64_to_int (buf
[11]) << 18;
1418 digest
[ 8] = (l
>> 0) & 0xff;
1419 digest
[ 7] = (l
>> 8) & 0xff;
1420 digest
[ 6] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[12]) << 0;
1423 l
|= itoa64_to_int (buf
[13]) << 6;
1424 l
|= itoa64_to_int (buf
[14]) << 12;
1425 l
|= itoa64_to_int (buf
[15]) << 18;
1427 digest
[11] = (l
>> 0) & 0xff;
1428 digest
[10] = (l
>> 8) & 0xff;
1429 digest
[ 9] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[16]) << 0;
1432 l
|= itoa64_to_int (buf
[17]) << 6;
1433 l
|= itoa64_to_int (buf
[18]) << 12;
1434 l
|= itoa64_to_int (buf
[19]) << 18;
1436 digest
[14] = (l
>> 0) & 0xff;
1437 digest
[13] = (l
>> 8) & 0xff;
1438 digest
[12] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[20]) << 0;
1441 l
|= itoa64_to_int (buf
[21]) << 6;
1442 l
|= itoa64_to_int (buf
[22]) << 12;
1443 l
|= itoa64_to_int (buf
[23]) << 18;
1445 digest
[17] = (l
>> 0) & 0xff;
1446 digest
[16] = (l
>> 8) & 0xff;
1447 digest
[15] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[24]) << 0;
1450 l
|= itoa64_to_int (buf
[25]) << 6;
1451 l
|= itoa64_to_int (buf
[26]) << 12;
1452 l
|= itoa64_to_int (buf
[27]) << 18;
1454 digest
[20] = (l
>> 0) & 0xff;
1455 digest
[19] = (l
>> 8) & 0xff;
1456 digest
[18] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[28]) << 0;
1459 l
|= itoa64_to_int (buf
[29]) << 6;
1460 l
|= itoa64_to_int (buf
[30]) << 12;
1461 l
|= itoa64_to_int (buf
[31]) << 18;
1463 digest
[23] = (l
>> 0) & 0xff;
1464 digest
[22] = (l
>> 8) & 0xff;
1465 digest
[21] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[32]) << 0;
1468 l
|= itoa64_to_int (buf
[33]) << 6;
1469 l
|= itoa64_to_int (buf
[34]) << 12;
1470 l
|= itoa64_to_int (buf
[35]) << 18;
1472 digest
[26] = (l
>> 0) & 0xff;
1473 digest
[25] = (l
>> 8) & 0xff;
1474 digest
[24] = (l
>> 16) & 0xff;
1476 l
= itoa64_to_int (buf
[36]) << 0;
1477 l
|= itoa64_to_int (buf
[37]) << 6;
1478 l
|= itoa64_to_int (buf
[38]) << 12;
1479 l
|= itoa64_to_int (buf
[39]) << 18;
1481 digest
[29] = (l
>> 0) & 0xff;
1482 digest
[28] = (l
>> 8) & 0xff;
1483 digest
[27] = (l
>> 16) & 0xff;
1485 l
= itoa64_to_int (buf
[40]) << 0;
1486 l
|= itoa64_to_int (buf
[41]) << 6;
1487 l
|= itoa64_to_int (buf
[42]) << 12;
1489 //digest[32] = (l >> 0) & 0xff;
1490 digest
[31] = (l
>> 8) & 0xff;
1491 digest
[30] = (l
>> 16) & 0xff;
1494 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1498 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1500 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1507 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1514 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[11] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1521 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[15] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1528 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[19] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1535 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[23] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1542 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[27] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1549 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[31] = int_to_itoa64 (l
& 0x3f);
1554 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1556 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[35] = int_to_itoa64 (l
& 0x3f);
1561 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1563 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1565 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1566 buf
[39] = int_to_itoa64 (l
& 0x3f);
1568 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1570 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1572 buf
[42] = int_to_itoa64 (l
& 0x3f);
1575 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1579 l
= itoa64_to_int (buf
[ 0]) << 0;
1580 l
|= itoa64_to_int (buf
[ 1]) << 6;
1581 l
|= itoa64_to_int (buf
[ 2]) << 12;
1582 l
|= itoa64_to_int (buf
[ 3]) << 18;
1584 digest
[ 2] = (l
>> 0) & 0xff;
1585 digest
[ 1] = (l
>> 8) & 0xff;
1586 digest
[ 0] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[ 4]) << 0;
1589 l
|= itoa64_to_int (buf
[ 5]) << 6;
1590 l
|= itoa64_to_int (buf
[ 6]) << 12;
1591 l
|= itoa64_to_int (buf
[ 7]) << 18;
1593 digest
[ 5] = (l
>> 0) & 0xff;
1594 digest
[ 4] = (l
>> 8) & 0xff;
1595 digest
[ 3] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[ 8]) << 0;
1598 l
|= itoa64_to_int (buf
[ 9]) << 6;
1599 l
|= itoa64_to_int (buf
[10]) << 12;
1600 l
|= itoa64_to_int (buf
[11]) << 18;
1602 digest
[ 8] = (l
>> 0) & 0xff;
1603 digest
[ 7] = (l
>> 8) & 0xff;
1604 digest
[ 6] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[12]) << 0;
1607 l
|= itoa64_to_int (buf
[13]) << 6;
1608 l
|= itoa64_to_int (buf
[14]) << 12;
1609 l
|= itoa64_to_int (buf
[15]) << 18;
1611 digest
[11] = (l
>> 0) & 0xff;
1612 digest
[10] = (l
>> 8) & 0xff;
1613 digest
[ 9] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[16]) << 0;
1616 l
|= itoa64_to_int (buf
[17]) << 6;
1617 l
|= itoa64_to_int (buf
[18]) << 12;
1618 l
|= itoa64_to_int (buf
[19]) << 18;
1620 digest
[14] = (l
>> 0) & 0xff;
1621 digest
[13] = (l
>> 8) & 0xff;
1622 digest
[12] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[20]) << 0;
1625 l
|= itoa64_to_int (buf
[21]) << 6;
1626 l
|= itoa64_to_int (buf
[22]) << 12;
1627 l
|= itoa64_to_int (buf
[23]) << 18;
1629 digest
[17] = (l
>> 0) & 0xff;
1630 digest
[16] = (l
>> 8) & 0xff;
1631 digest
[15] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[24]) << 0;
1634 l
|= itoa64_to_int (buf
[25]) << 6;
1635 l
|= itoa64_to_int (buf
[26]) << 12;
1636 l
|= itoa64_to_int (buf
[27]) << 18;
1638 digest
[20] = (l
>> 0) & 0xff;
1639 digest
[19] = (l
>> 8) & 0xff;
1640 digest
[18] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[28]) << 0;
1643 l
|= itoa64_to_int (buf
[29]) << 6;
1644 l
|= itoa64_to_int (buf
[30]) << 12;
1645 l
|= itoa64_to_int (buf
[31]) << 18;
1647 digest
[23] = (l
>> 0) & 0xff;
1648 digest
[22] = (l
>> 8) & 0xff;
1649 digest
[21] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[32]) << 0;
1652 l
|= itoa64_to_int (buf
[33]) << 6;
1653 l
|= itoa64_to_int (buf
[34]) << 12;
1654 l
|= itoa64_to_int (buf
[35]) << 18;
1656 digest
[26] = (l
>> 0) & 0xff;
1657 digest
[25] = (l
>> 8) & 0xff;
1658 digest
[24] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[36]) << 0;
1661 l
|= itoa64_to_int (buf
[37]) << 6;
1662 l
|= itoa64_to_int (buf
[38]) << 12;
1663 l
|= itoa64_to_int (buf
[39]) << 18;
1665 digest
[29] = (l
>> 0) & 0xff;
1666 digest
[28] = (l
>> 8) & 0xff;
1667 digest
[27] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[40]) << 0;
1670 l
|= itoa64_to_int (buf
[41]) << 6;
1671 l
|= itoa64_to_int (buf
[42]) << 12;
1672 l
|= itoa64_to_int (buf
[43]) << 18;
1674 digest
[32] = (l
>> 0) & 0xff;
1675 digest
[31] = (l
>> 8) & 0xff;
1676 digest
[30] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[44]) << 0;
1679 l
|= itoa64_to_int (buf
[45]) << 6;
1680 l
|= itoa64_to_int (buf
[46]) << 12;
1681 l
|= itoa64_to_int (buf
[47]) << 18;
1683 digest
[35] = (l
>> 0) & 0xff;
1684 digest
[34] = (l
>> 8) & 0xff;
1685 digest
[33] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[48]) << 0;
1688 l
|= itoa64_to_int (buf
[49]) << 6;
1689 l
|= itoa64_to_int (buf
[50]) << 12;
1690 l
|= itoa64_to_int (buf
[51]) << 18;
1692 digest
[38] = (l
>> 0) & 0xff;
1693 digest
[37] = (l
>> 8) & 0xff;
1694 digest
[36] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[52]) << 0;
1697 l
|= itoa64_to_int (buf
[53]) << 6;
1698 l
|= itoa64_to_int (buf
[54]) << 12;
1699 l
|= itoa64_to_int (buf
[55]) << 18;
1701 digest
[41] = (l
>> 0) & 0xff;
1702 digest
[40] = (l
>> 8) & 0xff;
1703 digest
[39] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[56]) << 0;
1706 l
|= itoa64_to_int (buf
[57]) << 6;
1707 l
|= itoa64_to_int (buf
[58]) << 12;
1708 l
|= itoa64_to_int (buf
[59]) << 18;
1710 digest
[44] = (l
>> 0) & 0xff;
1711 digest
[43] = (l
>> 8) & 0xff;
1712 digest
[42] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[60]) << 0;
1715 l
|= itoa64_to_int (buf
[61]) << 6;
1716 l
|= itoa64_to_int (buf
[62]) << 12;
1717 l
|= itoa64_to_int (buf
[63]) << 18;
1719 digest
[47] = (l
>> 0) & 0xff;
1720 digest
[46] = (l
>> 8) & 0xff;
1721 digest
[45] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[64]) << 0;
1724 l
|= itoa64_to_int (buf
[65]) << 6;
1725 l
|= itoa64_to_int (buf
[66]) << 12;
1726 l
|= itoa64_to_int (buf
[67]) << 18;
1728 digest
[50] = (l
>> 0) & 0xff;
1729 digest
[49] = (l
>> 8) & 0xff;
1730 digest
[48] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[68]) << 0;
1733 l
|= itoa64_to_int (buf
[69]) << 6;
1734 l
|= itoa64_to_int (buf
[70]) << 12;
1735 l
|= itoa64_to_int (buf
[71]) << 18;
1737 digest
[53] = (l
>> 0) & 0xff;
1738 digest
[52] = (l
>> 8) & 0xff;
1739 digest
[51] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[72]) << 0;
1742 l
|= itoa64_to_int (buf
[73]) << 6;
1743 l
|= itoa64_to_int (buf
[74]) << 12;
1744 l
|= itoa64_to_int (buf
[75]) << 18;
1746 digest
[56] = (l
>> 0) & 0xff;
1747 digest
[55] = (l
>> 8) & 0xff;
1748 digest
[54] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[76]) << 0;
1751 l
|= itoa64_to_int (buf
[77]) << 6;
1752 l
|= itoa64_to_int (buf
[78]) << 12;
1753 l
|= itoa64_to_int (buf
[79]) << 18;
1755 digest
[59] = (l
>> 0) & 0xff;
1756 digest
[58] = (l
>> 8) & 0xff;
1757 digest
[57] = (l
>> 16) & 0xff;
1759 l
= itoa64_to_int (buf
[80]) << 0;
1760 l
|= itoa64_to_int (buf
[81]) << 6;
1761 l
|= itoa64_to_int (buf
[82]) << 12;
1762 l
|= itoa64_to_int (buf
[83]) << 18;
1764 digest
[62] = (l
>> 0) & 0xff;
1765 digest
[61] = (l
>> 8) & 0xff;
1766 digest
[60] = (l
>> 16) & 0xff;
1768 l
= itoa64_to_int (buf
[84]) << 0;
1769 l
|= itoa64_to_int (buf
[85]) << 6;
1771 digest
[63] = (l
>> 16) & 0xff;
1774 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1778 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1780 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1787 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1794 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[11] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1801 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[15] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1808 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[19] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1815 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[23] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1822 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[27] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1829 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[31] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1836 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[35] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1843 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[39] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1850 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[43] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1857 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[47] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1864 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[51] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1871 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[55] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1878 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[59] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1885 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[63] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1892 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[67] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1899 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[71] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1906 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[75] = int_to_itoa64 (l
& 0x3f);
1911 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1913 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1915 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[79] = int_to_itoa64 (l
& 0x3f);
1918 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1920 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1922 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1923 buf
[83] = int_to_itoa64 (l
& 0x3f);
1925 l
= 0 | 0 | (digest
[63] << 16);
1927 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1931 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1935 l
= itoa64_to_int (buf
[ 0]) << 0;
1936 l
|= itoa64_to_int (buf
[ 1]) << 6;
1937 l
|= itoa64_to_int (buf
[ 2]) << 12;
1938 l
|= itoa64_to_int (buf
[ 3]) << 18;
1940 digest
[ 0] = (l
>> 16) & 0xff;
1941 digest
[10] = (l
>> 8) & 0xff;
1942 digest
[20] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[ 4]) << 0;
1945 l
|= itoa64_to_int (buf
[ 5]) << 6;
1946 l
|= itoa64_to_int (buf
[ 6]) << 12;
1947 l
|= itoa64_to_int (buf
[ 7]) << 18;
1949 digest
[21] = (l
>> 16) & 0xff;
1950 digest
[ 1] = (l
>> 8) & 0xff;
1951 digest
[11] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[ 8]) << 0;
1954 l
|= itoa64_to_int (buf
[ 9]) << 6;
1955 l
|= itoa64_to_int (buf
[10]) << 12;
1956 l
|= itoa64_to_int (buf
[11]) << 18;
1958 digest
[12] = (l
>> 16) & 0xff;
1959 digest
[22] = (l
>> 8) & 0xff;
1960 digest
[ 2] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[12]) << 0;
1963 l
|= itoa64_to_int (buf
[13]) << 6;
1964 l
|= itoa64_to_int (buf
[14]) << 12;
1965 l
|= itoa64_to_int (buf
[15]) << 18;
1967 digest
[ 3] = (l
>> 16) & 0xff;
1968 digest
[13] = (l
>> 8) & 0xff;
1969 digest
[23] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[16]) << 0;
1972 l
|= itoa64_to_int (buf
[17]) << 6;
1973 l
|= itoa64_to_int (buf
[18]) << 12;
1974 l
|= itoa64_to_int (buf
[19]) << 18;
1976 digest
[24] = (l
>> 16) & 0xff;
1977 digest
[ 4] = (l
>> 8) & 0xff;
1978 digest
[14] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[20]) << 0;
1981 l
|= itoa64_to_int (buf
[21]) << 6;
1982 l
|= itoa64_to_int (buf
[22]) << 12;
1983 l
|= itoa64_to_int (buf
[23]) << 18;
1985 digest
[15] = (l
>> 16) & 0xff;
1986 digest
[25] = (l
>> 8) & 0xff;
1987 digest
[ 5] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[24]) << 0;
1990 l
|= itoa64_to_int (buf
[25]) << 6;
1991 l
|= itoa64_to_int (buf
[26]) << 12;
1992 l
|= itoa64_to_int (buf
[27]) << 18;
1994 digest
[ 6] = (l
>> 16) & 0xff;
1995 digest
[16] = (l
>> 8) & 0xff;
1996 digest
[26] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[28]) << 0;
1999 l
|= itoa64_to_int (buf
[29]) << 6;
2000 l
|= itoa64_to_int (buf
[30]) << 12;
2001 l
|= itoa64_to_int (buf
[31]) << 18;
2003 digest
[27] = (l
>> 16) & 0xff;
2004 digest
[ 7] = (l
>> 8) & 0xff;
2005 digest
[17] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[32]) << 0;
2008 l
|= itoa64_to_int (buf
[33]) << 6;
2009 l
|= itoa64_to_int (buf
[34]) << 12;
2010 l
|= itoa64_to_int (buf
[35]) << 18;
2012 digest
[18] = (l
>> 16) & 0xff;
2013 digest
[28] = (l
>> 8) & 0xff;
2014 digest
[ 8] = (l
>> 0) & 0xff;
2016 l
= itoa64_to_int (buf
[36]) << 0;
2017 l
|= itoa64_to_int (buf
[37]) << 6;
2018 l
|= itoa64_to_int (buf
[38]) << 12;
2019 l
|= itoa64_to_int (buf
[39]) << 18;
2021 digest
[ 9] = (l
>> 16) & 0xff;
2022 digest
[19] = (l
>> 8) & 0xff;
2023 digest
[29] = (l
>> 0) & 0xff;
2025 l
= itoa64_to_int (buf
[40]) << 0;
2026 l
|= itoa64_to_int (buf
[41]) << 6;
2027 l
|= itoa64_to_int (buf
[42]) << 12;
2029 digest
[31] = (l
>> 8) & 0xff;
2030 digest
[30] = (l
>> 0) & 0xff;
2033 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2037 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2039 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2046 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2053 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2060 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2067 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2074 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2081 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2088 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2095 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2102 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2104 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2107 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2109 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2111 buf
[42] = int_to_itoa64 (l
& 0x3f);
2114 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2118 l
= itoa64_to_int (buf
[ 0]) << 0;
2119 l
|= itoa64_to_int (buf
[ 1]) << 6;
2120 l
|= itoa64_to_int (buf
[ 2]) << 12;
2121 l
|= itoa64_to_int (buf
[ 3]) << 18;
2123 digest
[ 0] = (l
>> 0) & 0xff;
2124 digest
[ 1] = (l
>> 8) & 0xff;
2125 digest
[ 2] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[ 4]) << 0;
2128 l
|= itoa64_to_int (buf
[ 5]) << 6;
2129 l
|= itoa64_to_int (buf
[ 6]) << 12;
2130 l
|= itoa64_to_int (buf
[ 7]) << 18;
2132 digest
[ 3] = (l
>> 0) & 0xff;
2133 digest
[ 4] = (l
>> 8) & 0xff;
2134 digest
[ 5] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[ 8]) << 0;
2137 l
|= itoa64_to_int (buf
[ 9]) << 6;
2138 l
|= itoa64_to_int (buf
[10]) << 12;
2139 l
|= itoa64_to_int (buf
[11]) << 18;
2141 digest
[ 6] = (l
>> 0) & 0xff;
2142 digest
[ 7] = (l
>> 8) & 0xff;
2143 digest
[ 8] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[12]) << 0;
2146 l
|= itoa64_to_int (buf
[13]) << 6;
2147 l
|= itoa64_to_int (buf
[14]) << 12;
2148 l
|= itoa64_to_int (buf
[15]) << 18;
2150 digest
[ 9] = (l
>> 0) & 0xff;
2151 digest
[10] = (l
>> 8) & 0xff;
2152 digest
[11] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[16]) << 0;
2155 l
|= itoa64_to_int (buf
[17]) << 6;
2156 l
|= itoa64_to_int (buf
[18]) << 12;
2157 l
|= itoa64_to_int (buf
[19]) << 18;
2159 digest
[12] = (l
>> 0) & 0xff;
2160 digest
[13] = (l
>> 8) & 0xff;
2161 digest
[14] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[20]) << 0;
2164 l
|= itoa64_to_int (buf
[21]) << 6;
2165 l
|= itoa64_to_int (buf
[22]) << 12;
2166 l
|= itoa64_to_int (buf
[23]) << 18;
2168 digest
[15] = (l
>> 0) & 0xff;
2169 digest
[16] = (l
>> 8) & 0xff;
2170 digest
[17] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[24]) << 0;
2173 l
|= itoa64_to_int (buf
[25]) << 6;
2174 l
|= itoa64_to_int (buf
[26]) << 12;
2175 l
|= itoa64_to_int (buf
[27]) << 18;
2177 digest
[18] = (l
>> 0) & 0xff;
2178 digest
[19] = (l
>> 8) & 0xff;
2179 digest
[20] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[28]) << 0;
2182 l
|= itoa64_to_int (buf
[29]) << 6;
2183 l
|= itoa64_to_int (buf
[30]) << 12;
2184 l
|= itoa64_to_int (buf
[31]) << 18;
2186 digest
[21] = (l
>> 0) & 0xff;
2187 digest
[22] = (l
>> 8) & 0xff;
2188 digest
[23] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[32]) << 0;
2191 l
|= itoa64_to_int (buf
[33]) << 6;
2192 l
|= itoa64_to_int (buf
[34]) << 12;
2193 l
|= itoa64_to_int (buf
[35]) << 18;
2195 digest
[24] = (l
>> 0) & 0xff;
2196 digest
[25] = (l
>> 8) & 0xff;
2197 digest
[26] = (l
>> 16) & 0xff;
2199 l
= itoa64_to_int (buf
[36]) << 0;
2200 l
|= itoa64_to_int (buf
[37]) << 6;
2201 l
|= itoa64_to_int (buf
[38]) << 12;
2202 l
|= itoa64_to_int (buf
[39]) << 18;
2204 digest
[27] = (l
>> 0) & 0xff;
2205 digest
[28] = (l
>> 8) & 0xff;
2206 digest
[29] = (l
>> 16) & 0xff;
2208 l
= itoa64_to_int (buf
[40]) << 0;
2209 l
|= itoa64_to_int (buf
[41]) << 6;
2210 l
|= itoa64_to_int (buf
[42]) << 12;
2211 l
|= itoa64_to_int (buf
[43]) << 18;
2213 digest
[30] = (l
>> 0) & 0xff;
2214 digest
[31] = (l
>> 8) & 0xff;
2215 digest
[32] = (l
>> 16) & 0xff;
2250 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2254 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2256 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2263 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2270 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[11] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2277 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[15] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2284 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[19] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2291 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[23] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2298 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[27] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2305 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[31] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2312 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[35] = int_to_itoa64 (l
& 0x3f);
2317 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2319 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2321 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2322 buf
[39] = int_to_itoa64 (l
& 0x3f);
2324 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2326 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2328 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2329 //buf[43] = int_to_itoa64 (l & 0x3f);
2337 static struct termio savemodes
;
2338 static int havemodes
= 0;
2342 struct termio modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3409 return (clocksThrottleReasons
> 0);
3415 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3417 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3421 if (data
.hm_device
[device_id
].od_version
== 5)
3423 ADLFanSpeedValue lpFanSpeedValue
;
3425 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3427 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3428 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3429 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3430 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3432 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3436 else // od_version == 6
3438 ADLOD6FanSpeedValue fan_speed_value
;
3440 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3442 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3443 fan_speed_value
.iFanSpeed
= fanspeed
;
3445 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3455 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3457 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3461 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3463 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3465 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3466 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3468 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3477 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3479 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3481 if (data
.hm_xnvctrl
)
3483 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3492 #endif // HAVE_HWMON
3498 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3500 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3502 if (css_cnt
> SP_PW_MAX
)
3504 log_error ("ERROR: Mask length is too long");
3509 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3511 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3513 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3514 uint cs_len
= css
[css_pos
].cs_len
;
3516 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3518 uint c
= cs_buf
[cs_pos
] & 0xff;
3525 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3527 cs_t
*cs
= &css
[css_cnt
];
3529 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3531 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3535 for (i
= 0; i
< cs
->cs_len
; i
++)
3537 const uint u
= cs
->cs_buf
[i
];
3542 for (i
= 0; i
< in_len
; i
++)
3544 uint u
= in_buf
[i
] & 0xff;
3546 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3548 if (css_uniq
[u
] == 1) continue;
3552 cs
->cs_buf
[cs
->cs_len
] = u
;
3560 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3564 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3566 uint p0
= in_buf
[in_pos
] & 0xff;
3568 if (interpret
== 1 && p0
== '?')
3572 if (in_pos
== in_len
) break;
3574 uint p1
= in_buf
[in_pos
] & 0xff;
3578 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3580 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3582 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3584 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3586 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3588 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3590 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3591 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3593 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3594 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3596 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3597 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3599 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3600 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3602 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3604 default: log_error ("Syntax error: %s", in_buf
);
3610 if (data
.hex_charset
)
3614 if (in_pos
== in_len
)
3616 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3621 uint p1
= in_buf
[in_pos
] & 0xff;
3623 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3625 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3632 chr
= hex_convert (p1
) << 0;
3633 chr
|= hex_convert (p0
) << 4;
3635 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3641 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3647 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3651 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3653 sum
*= css
[css_pos
].cs_len
;
3659 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3661 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 char p0
= mask_buf
[mask_pos
];
3674 if (mask_pos
== mask_len
) break;
3676 char p1
= mask_buf
[mask_pos
];
3682 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3684 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3686 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3688 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3690 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3692 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3694 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3695 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3697 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3698 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3700 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3701 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3703 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3704 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3706 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3708 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3714 if (data
.hex_charset
)
3718 // if there is no 2nd hex character, show an error:
3720 if (mask_pos
== mask_len
)
3722 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3727 char p1
= mask_buf
[mask_pos
];
3729 // if they are not valid hex character, show an error:
3731 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3733 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3740 chr
|= hex_convert (p1
) << 0;
3741 chr
|= hex_convert (p0
) << 4;
3743 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3749 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3756 log_error ("ERROR: Invalid mask length (0)");
3766 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3768 for (int i
= 0; i
< css_cnt
; i
++)
3770 uint len
= css
[i
].cs_len
;
3771 u64 next
= val
/ len
;
3772 uint pos
= val
% len
;
3773 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3778 void mp_cut_at (char *mask
, uint max
)
3782 uint mask_len
= strlen (mask
);
3784 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3786 if (mask
[i
] == '?') i
++;
3792 void mp_setup_sys (cs_t
*mp_sys
)
3796 uint donec
[CHARSIZ
] = { 0 };
3798 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3799 mp_sys
[0].cs_buf
[pos
++] = chr
;
3800 mp_sys
[0].cs_len
= pos
; }
3802 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3803 mp_sys
[1].cs_buf
[pos
++] = chr
;
3804 mp_sys
[1].cs_len
= pos
; }
3806 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3807 mp_sys
[2].cs_buf
[pos
++] = chr
;
3808 mp_sys
[2].cs_len
= pos
; }
3810 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3811 mp_sys
[3].cs_buf
[pos
++] = chr
;
3812 mp_sys
[3].cs_len
= pos
; }
3814 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3815 mp_sys
[4].cs_len
= pos
; }
3817 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3818 mp_sys
[5].cs_len
= pos
; }
3821 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3823 FILE *fp
= fopen (buf
, "rb");
3825 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3827 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3831 char mp_file
[1024] = { 0 };
3833 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3837 len
= in_superchop (mp_file
);
3841 log_info ("WARNING: Charset file corrupted");
3843 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3847 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3852 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3854 mp_usr
[index
].cs_len
= 0;
3856 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3859 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3861 char *new_mask_buf
= (char *) mymalloc (256);
3867 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3869 if (css_pos
== len
) break;
3871 char p0
= mask_buf
[mask_pos
];
3873 new_mask_buf
[mask_pos
] = p0
;
3879 if (mask_pos
== mask_len
) break;
3881 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3885 if (data
.hex_charset
)
3889 if (mask_pos
== mask_len
)
3891 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3896 char p1
= mask_buf
[mask_pos
];
3898 // if they are not valid hex character, show an error:
3900 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3902 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3907 new_mask_buf
[mask_pos
] = p1
;
3912 if (css_pos
== len
) return (new_mask_buf
);
3914 myfree (new_mask_buf
);
3923 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3929 for (i
= start
; i
< stop
; i
++)
3931 sum
*= root_css_buf
[i
].cs_len
;
3937 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3941 cs_t
*cs
= &root_css_buf
[start
];
3945 for (i
= start
; i
< stop
; i
++)
3947 const u64 m
= v
% cs
->cs_len
;
3948 const u64 d
= v
/ cs
->cs_len
;
3952 const uint k
= cs
->cs_buf
[m
];
3954 pw_buf
[i
- start
] = (char) k
;
3956 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3960 int sp_comp_val (const void *p1
, const void *p2
)
3962 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3963 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3965 return b2
->val
- b1
->val
;
3968 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3975 * Initialize hcstats
3978 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3980 u64
*root_stats_ptr
= root_stats_buf
;
3982 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3984 for (i
= 0; i
< SP_PW_MAX
; i
++)
3986 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3988 root_stats_ptr
+= CHARSIZ
;
3991 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3993 u64
*markov_stats_ptr
= markov_stats_buf
;
3995 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3997 for (i
= 0; i
< SP_PW_MAX
; i
++)
3999 for (j
= 0; j
< CHARSIZ
; j
++)
4001 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4003 markov_stats_ptr
+= CHARSIZ
;
4013 char hcstat_tmp
[256] = { 0 };
4015 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4017 hcstat
= hcstat_tmp
;
4020 FILE *fd
= fopen (hcstat
, "rb");
4024 log_error ("%s: %s", hcstat
, strerror (errno
));
4029 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4031 log_error ("%s: Could not load data", hcstat
);
4038 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4040 log_error ("%s: Could not load data", hcstat
);
4050 * Markov modifier of hcstat_table on user request
4055 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4056 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4061 /* Add all stats to first position */
4063 for (i
= 1; i
< SP_PW_MAX
; i
++)
4065 u64
*out
= root_stats_buf_by_pos
[0];
4066 u64
*in
= root_stats_buf_by_pos
[i
];
4068 for (j
= 0; j
< CHARSIZ
; j
++)
4074 for (i
= 1; i
< SP_PW_MAX
; i
++)
4076 u64
*out
= markov_stats_buf_by_key
[0][0];
4077 u64
*in
= markov_stats_buf_by_key
[i
][0];
4079 for (j
= 0; j
< CHARSIZ
; j
++)
4081 for (k
= 0; k
< CHARSIZ
; k
++)
4088 /* copy them to all pw_positions */
4090 for (i
= 1; i
< SP_PW_MAX
; i
++)
4092 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4095 for (i
= 1; i
< SP_PW_MAX
; i
++)
4097 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4105 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4107 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4109 for (i
= 0; i
< SP_PW_MAX
; i
++)
4111 root_table_buf_by_pos
[i
] = root_table_ptr
;
4113 root_table_ptr
+= CHARSIZ
;
4116 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4118 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4120 for (i
= 0; i
< SP_PW_MAX
; i
++)
4122 for (j
= 0; j
< CHARSIZ
; j
++)
4124 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4126 markov_table_ptr
+= CHARSIZ
;
4131 * Convert hcstat to tables
4134 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4136 uint key
= i
% CHARSIZ
;
4138 root_table_buf
[i
].key
= key
;
4139 root_table_buf
[i
].val
= root_stats_buf
[i
];
4142 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4144 uint key
= i
% CHARSIZ
;
4146 markov_table_buf
[i
].key
= key
;
4147 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4150 myfree (root_stats_buf
);
4151 myfree (markov_stats_buf
);
4157 for (i
= 0; i
< SP_PW_MAX
; i
++)
4159 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4162 for (i
= 0; i
< SP_PW_MAX
; i
++)
4164 for (j
= 0; j
< CHARSIZ
; j
++)
4166 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4171 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4174 * Convert tables to css
4177 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4179 uint pw_pos
= i
/ CHARSIZ
;
4181 cs_t
*cs
= &root_css_buf
[pw_pos
];
4183 if (cs
->cs_len
== threshold
) continue;
4185 uint key
= root_table_buf
[i
].key
;
4187 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4189 cs
->cs_buf
[cs
->cs_len
] = key
;
4195 * Convert table to css
4198 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4200 uint c
= i
/ CHARSIZ
;
4202 cs_t
*cs
= &markov_css_buf
[c
];
4204 if (cs
->cs_len
== threshold
) continue;
4206 uint pw_pos
= c
/ CHARSIZ
;
4208 uint key
= markov_table_buf
[i
].key
;
4210 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4212 cs
->cs_buf
[cs
->cs_len
] = key
;
4218 for (uint i = 0; i < 8; i++)
4220 for (uint j = 0x20; j < 0x80; j++)
4222 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4224 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4226 for (uint k = 0; k < 10; k++)
4228 printf (" %u\n", ptr->cs_buf[k]);
4235 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4237 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4239 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4249 for (uint j
= 1; j
< CHARSIZ
; j
++)
4259 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4261 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4263 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4265 out
+= CHARSIZ
* CHARSIZ
;
4266 in
+= CHARSIZ
* CHARSIZ
;
4268 for (uint j
= 0; j
< CHARSIZ
; j
++)
4275 for (uint k
= 1; k
< CHARSIZ
; k
++)
4287 * mixed shared functions
4290 void dump_hex (const u8
*s
, const int sz
)
4292 for (int i
= 0; i
< sz
; i
++)
4294 log_info_nn ("%02x ", s
[i
]);
4300 void usage_mini_print (const char *progname
)
4302 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4305 void usage_big_print (const char *progname
)
4307 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4310 char *get_exec_path ()
4312 int exec_path_len
= 1024;
4314 char *exec_path
= (char *) mymalloc (exec_path_len
);
4318 char tmp
[32] = { 0 };
4320 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4322 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4326 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4330 uint size
= exec_path_len
;
4332 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4334 log_error("! executable path buffer too small\n");
4339 const int len
= strlen (exec_path
);
4342 #error Your Operating System is not supported or detected
4350 char *get_install_dir (const char *progname
)
4352 char *install_dir
= mystrdup (progname
);
4353 char *last_slash
= NULL
;
4355 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4359 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4365 install_dir
[0] = '.';
4369 return (install_dir
);
4372 char *get_profile_dir (const char *homedir
)
4374 #define DOT_HASHCAT ".hashcat"
4376 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4378 char *profile_dir
= (char *) mymalloc (len
+ 1);
4380 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4385 char *get_session_dir (const char *profile_dir
)
4387 #define SESSIONS_FOLDER "sessions"
4389 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4391 char *session_dir
= (char *) mymalloc (len
+ 1);
4393 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4398 uint
count_lines (FILE *fd
)
4402 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4408 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4410 if (nread
< 1) continue;
4414 for (i
= 0; i
< nread
; i
++)
4416 if (prev
== '\n') cnt
++;
4427 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4431 FILE *fd
= fopen (filename
, "rb");
4435 log_error ("%s: %s", filename
, strerror (errno
));
4440 #define MAX_KEY_SIZE (1024 * 1024)
4442 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4444 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4450 for (int fpos
= 0; fpos
< nread
; fpos
++)
4452 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4454 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4455 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4456 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4457 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4459 if (kpos
>= 64) kpos
= 0;
4466 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4470 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4471 if (CPU_ISSET(core
, cpu_set
)) break;
4473 thread_affinity_policy_data_t policy
= { core
};
4475 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4477 if (data
.quiet
== 0)
4479 if (rc
!= KERN_SUCCESS
)
4481 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4489 void set_cpu_affinity (char *cpu_affinity
)
4492 DWORD_PTR aff_mask
= 0;
4500 char *devices
= strdup (cpu_affinity
);
4502 char *next
= strtok (devices
, ",");
4506 uint cpu_id
= atoi (next
);
4521 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4527 aff_mask
|= 1 << (cpu_id
- 1);
4529 CPU_SET ((cpu_id
- 1), &cpuset
);
4532 } while ((next
= strtok (NULL
, ",")) != NULL
);
4538 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4539 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4541 pthread_t thread
= pthread_self ();
4542 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4546 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4548 char *element
, *end
;
4550 end
= (char *) base
+ nmemb
* size
;
4552 for (element
= (char *) base
; element
< end
; element
+= size
)
4553 if (!compar (element
, key
))
4559 int sort_by_u32 (const void *v1
, const void *v2
)
4561 const u32
*s1
= (const u32
*) v1
;
4562 const u32
*s2
= (const u32
*) v2
;
4567 int sort_by_salt (const void *v1
, const void *v2
)
4569 const salt_t
*s1
= (const salt_t
*) v1
;
4570 const salt_t
*s2
= (const salt_t
*) v2
;
4572 const int res1
= s1
->salt_len
- s2
->salt_len
;
4574 if (res1
!= 0) return (res1
);
4576 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4578 if (res2
!= 0) return (res2
);
4586 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4587 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4594 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4595 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4601 int sort_by_salt_buf (const void *v1
, const void *v2
)
4603 const pot_t
*p1
= (const pot_t
*) v1
;
4604 const pot_t
*p2
= (const pot_t
*) v2
;
4606 const hash_t
*h1
= &p1
->hash
;
4607 const hash_t
*h2
= &p2
->hash
;
4609 const salt_t
*s1
= h1
->salt
;
4610 const salt_t
*s2
= h2
->salt
;
4616 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4617 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4623 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4625 const hash_t
*h1
= (const hash_t
*) v1
;
4626 const hash_t
*h2
= (const hash_t
*) v2
;
4628 const salt_t
*s1
= h1
->salt
;
4629 const salt_t
*s2
= h2
->salt
;
4631 // testphase: this should work
4636 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4637 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4640 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4641 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4642 if (s1->salt_len > s2->salt_len) return ( 1);
4643 if (s1->salt_len < s2->salt_len) return (-1);
4645 uint n = s1->salt_len;
4649 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4650 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4657 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4659 const hash_t
*h1
= (const hash_t
*) v1
;
4660 const hash_t
*h2
= (const hash_t
*) v2
;
4662 const salt_t
*s1
= h1
->salt
;
4663 const salt_t
*s2
= h2
->salt
;
4665 // 16 - 2 (since last 2 uints contain the digest)
4670 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4671 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4677 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4679 const hash_t
*h1
= (const hash_t
*) v1
;
4680 const hash_t
*h2
= (const hash_t
*) v2
;
4682 const void *d1
= h1
->digest
;
4683 const void *d2
= h2
->digest
;
4685 return data
.sort_by_digest (d1
, d2
);
4688 int sort_by_hash (const void *v1
, const void *v2
)
4690 const hash_t
*h1
= (const hash_t
*) v1
;
4691 const hash_t
*h2
= (const hash_t
*) v2
;
4695 const salt_t
*s1
= h1
->salt
;
4696 const salt_t
*s2
= h2
->salt
;
4698 int res
= sort_by_salt (s1
, s2
);
4700 if (res
!= 0) return (res
);
4703 const void *d1
= h1
->digest
;
4704 const void *d2
= h2
->digest
;
4706 return data
.sort_by_digest (d1
, d2
);
4709 int sort_by_pot (const void *v1
, const void *v2
)
4711 const pot_t
*p1
= (const pot_t
*) v1
;
4712 const pot_t
*p2
= (const pot_t
*) v2
;
4714 const hash_t
*h1
= &p1
->hash
;
4715 const hash_t
*h2
= &p2
->hash
;
4717 return sort_by_hash (h1
, h2
);
4720 int sort_by_mtime (const void *p1
, const void *p2
)
4722 const char **f1
= (const char **) p1
;
4723 const char **f2
= (const char **) p2
;
4725 struct stat s1
; stat (*f1
, &s1
);
4726 struct stat s2
; stat (*f2
, &s2
);
4728 return s2
.st_mtime
- s1
.st_mtime
;
4731 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4733 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4734 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4736 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4739 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4741 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4742 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4744 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4747 int sort_by_stringptr (const void *p1
, const void *p2
)
4749 const char **s1
= (const char **) p1
;
4750 const char **s2
= (const char **) p2
;
4752 return strcmp (*s1
, *s2
);
4755 int sort_by_dictstat (const void *s1
, const void *s2
)
4757 dictstat_t
*d1
= (dictstat_t
*) s1
;
4758 dictstat_t
*d2
= (dictstat_t
*) s2
;
4761 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4763 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4766 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4769 int sort_by_bitmap (const void *p1
, const void *p2
)
4771 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4772 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4774 return b1
->collisions
- b2
->collisions
;
4777 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4779 const u32
*d1
= (const u32
*) v1
;
4780 const u32
*d2
= (const u32
*) v2
;
4786 if (d1
[n
] > d2
[n
]) return ( 1);
4787 if (d1
[n
] < d2
[n
]) return (-1);
4793 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4795 const u32
*d1
= (const u32
*) v1
;
4796 const u32
*d2
= (const u32
*) v2
;
4802 if (d1
[n
] > d2
[n
]) return ( 1);
4803 if (d1
[n
] < d2
[n
]) return (-1);
4809 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4811 const u32
*d1
= (const u32
*) v1
;
4812 const u32
*d2
= (const u32
*) v2
;
4818 if (d1
[n
] > d2
[n
]) return ( 1);
4819 if (d1
[n
] < d2
[n
]) return (-1);
4825 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4827 const u32
*d1
= (const u32
*) v1
;
4828 const u32
*d2
= (const u32
*) v2
;
4834 if (d1
[n
] > d2
[n
]) return ( 1);
4835 if (d1
[n
] < d2
[n
]) return (-1);
4841 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4843 const u32
*d1
= (const u32
*) v1
;
4844 const u32
*d2
= (const u32
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4859 const u32
*d1
= (const u32
*) v1
;
4860 const u32
*d2
= (const u32
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4882 if (d1
[n
] > d2
[n
]) return ( 1);
4883 if (d1
[n
] < d2
[n
]) return (-1);
4889 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4891 const u32
*d1
= (const u32
*) v1
;
4892 const u32
*d2
= (const u32
*) v2
;
4898 if (d1
[n
] > d2
[n
]) return ( 1);
4899 if (d1
[n
] < d2
[n
]) return (-1);
4905 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4907 const u64
*d1
= (const u64
*) v1
;
4908 const u64
*d2
= (const u64
*) v2
;
4914 if (d1
[n
] > d2
[n
]) return ( 1);
4915 if (d1
[n
] < d2
[n
]) return (-1);
4921 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4923 const u64
*d1
= (const u64
*) v1
;
4924 const u64
*d2
= (const u64
*) v2
;
4930 if (d1
[n
] > d2
[n
]) return ( 1);
4931 if (d1
[n
] < d2
[n
]) return (-1);
4937 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4939 const u64
*d1
= (const u64
*) v1
;
4940 const u64
*d2
= (const u64
*) v2
;
4946 if (d1
[n
] > d2
[n
]) return ( 1);
4947 if (d1
[n
] < d2
[n
]) return (-1);
4953 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4955 const u32
*d1
= (const u32
*) v1
;
4956 const u32
*d2
= (const u32
*) v2
;
4958 const uint dgst_pos0
= data
.dgst_pos0
;
4959 const uint dgst_pos1
= data
.dgst_pos1
;
4960 const uint dgst_pos2
= data
.dgst_pos2
;
4961 const uint dgst_pos3
= data
.dgst_pos3
;
4963 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4964 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4965 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4966 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4967 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4968 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4969 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4970 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4975 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4977 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4978 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4980 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4982 if (res1
!= 0) return (res1
);
4987 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4989 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4990 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4992 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4994 if (res1
!= 0) return (res1
);
4996 const int res2
= t1
->attack_mode
4999 if (res2
!= 0) return (res2
);
5001 const int res3
= t1
->hash_type
5004 if (res3
!= 0) return (res3
);
5009 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
5011 uint outfile_autohex
= data
.outfile_autohex
;
5013 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5015 FILE *debug_fp
= NULL
;
5017 if (debug_file
!= NULL
)
5019 debug_fp
= fopen (debug_file
, "ab");
5021 lock_file (debug_fp
);
5028 if (debug_fp
== NULL
)
5030 log_info ("WARNING: Could not open debug-file for writing");
5034 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5036 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5038 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5041 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5043 if (debug_mode
== 4)
5045 fputc (':', debug_fp
);
5047 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5050 fputc ('\n', debug_fp
);
5052 if (debug_file
!= NULL
) fclose (debug_fp
);
5056 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5058 int needs_hexify
= 0;
5060 if (outfile_autohex
== 1)
5062 for (uint i
= 0; i
< plain_len
; i
++)
5064 if (plain_ptr
[i
] < 0x20)
5071 if (plain_ptr
[i
] > 0x7f)
5080 if (needs_hexify
== 1)
5082 fprintf (fp
, "$HEX[");
5084 for (uint i
= 0; i
< plain_len
; i
++)
5086 fprintf (fp
, "%02x", plain_ptr
[i
]);
5093 fwrite (plain_ptr
, plain_len
, 1, fp
);
5097 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
5099 uint outfile_format
= data
.outfile_format
;
5101 char separator
= data
.separator
;
5103 if (outfile_format
& OUTFILE_FMT_HASH
)
5105 fprintf (out_fp
, "%s", out_buf
);
5107 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5109 fputc (separator
, out_fp
);
5112 else if (data
.username
)
5114 if (username
!= NULL
)
5116 for (uint i
= 0; i
< user_len
; i
++)
5118 fprintf (out_fp
, "%c", username
[i
]);
5121 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5123 fputc (separator
, out_fp
);
5128 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5130 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5132 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5134 fputc (separator
, out_fp
);
5138 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5140 for (uint i
= 0; i
< plain_len
; i
++)
5142 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5145 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5147 fputc (separator
, out_fp
);
5151 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5154 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5159 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5161 fprintf (out_fp
, "%llu", crackpos
);
5166 fputc ('\n', out_fp
);
5169 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5173 pot_key
.hash
.salt
= hashes_buf
->salt
;
5174 pot_key
.hash
.digest
= hashes_buf
->digest
;
5176 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5182 input_buf
[input_len
] = 0;
5185 unsigned char *username
= NULL
;
5190 user_t
*user
= hashes_buf
->hash_info
->user
;
5194 username
= (unsigned char *) (user
->user_name
);
5196 user_len
= user
->user_len
;
5200 // do output the line
5201 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5205 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5206 #define LM_MASKED_PLAIN "[notfound]"
5208 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5214 pot_left_key
.hash
.salt
= hash_left
->salt
;
5215 pot_left_key
.hash
.digest
= hash_left
->digest
;
5217 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5221 uint weak_hash_found
= 0;
5223 pot_t pot_right_key
;
5225 pot_right_key
.hash
.salt
= hash_right
->salt
;
5226 pot_right_key
.hash
.digest
= hash_right
->digest
;
5228 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5230 if (pot_right_ptr
== NULL
)
5232 // special case, if "weak hash"
5234 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5236 weak_hash_found
= 1;
5238 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5240 // in theory this is not needed, but we are paranoia:
5242 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5243 pot_right_ptr
->plain_len
= 0;
5247 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5249 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5254 // at least one half was found:
5258 input_buf
[input_len
] = 0;
5262 unsigned char *username
= NULL
;
5267 user_t
*user
= hash_left
->hash_info
->user
;
5271 username
= (unsigned char *) (user
->user_name
);
5273 user_len
= user
->user_len
;
5277 // mask the part which was not found
5279 uint left_part_masked
= 0;
5280 uint right_part_masked
= 0;
5282 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5284 if (pot_left_ptr
== NULL
)
5286 left_part_masked
= 1;
5288 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5290 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5292 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5293 pot_left_ptr
->plain_len
= mask_plain_len
;
5296 if (pot_right_ptr
== NULL
)
5298 right_part_masked
= 1;
5300 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5302 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5304 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5305 pot_right_ptr
->plain_len
= mask_plain_len
;
5308 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5312 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5314 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5316 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5318 // do output the line
5320 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5322 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5324 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5325 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5328 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5332 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5334 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5336 if (pot_ptr
== NULL
)
5340 input_buf
[input_len
] = 0;
5342 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5346 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5352 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5354 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5358 pot_t pot_right_key
;
5360 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5362 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5364 uint weak_hash_found
= 0;
5366 if (pot_right_ptr
== NULL
)
5368 // special case, if "weak hash"
5370 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5372 weak_hash_found
= 1;
5374 // we just need that pot_right_ptr is not a NULL pointer
5376 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5380 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5382 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5387 // ... at least one part was not cracked
5391 input_buf
[input_len
] = 0;
5393 // only show the hash part which is still not cracked
5395 uint user_len
= input_len
- 32;
5397 char *hash_output
= (char *) mymalloc (33);
5399 memcpy (hash_output
, input_buf
, input_len
);
5401 if (pot_left_ptr
!= NULL
)
5403 // only show right part (because left part was already found)
5405 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5407 hash_output
[user_len
+ 16] = 0;
5410 if (pot_right_ptr
!= NULL
)
5412 // only show left part (because right part was already found)
5414 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5416 hash_output
[user_len
+ 16] = 0;
5419 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5421 myfree (hash_output
);
5423 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5426 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5428 uint opencl_platforms_filter
= 0;
5430 if (opencl_platforms
)
5432 char *platforms
= strdup (opencl_platforms
);
5434 char *next
= strtok (platforms
, ",");
5438 int platform
= atoi (next
);
5440 if (platform
< 1 || platform
> 32)
5442 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5447 opencl_platforms_filter
|= 1 << (platform
- 1);
5449 } while ((next
= strtok (NULL
, ",")) != NULL
);
5455 opencl_platforms_filter
= -1;
5458 return opencl_platforms_filter
;
5461 u32
setup_devices_filter (char *opencl_devices
)
5463 u32 devices_filter
= 0;
5467 char *devices
= strdup (opencl_devices
);
5469 char *next
= strtok (devices
, ",");
5473 int device_id
= atoi (next
);
5475 if (device_id
< 1 || device_id
> 32)
5477 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5482 devices_filter
|= 1 << (device_id
- 1);
5484 } while ((next
= strtok (NULL
, ",")) != NULL
);
5490 devices_filter
= -1;
5493 return devices_filter
;
5496 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5498 cl_device_type device_types_filter
= 0;
5500 if (opencl_device_types
)
5502 char *device_types
= strdup (opencl_device_types
);
5504 char *next
= strtok (device_types
, ",");
5508 int device_type
= atoi (next
);
5510 if (device_type
< 1 || device_type
> 3)
5512 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5517 device_types_filter
|= 1 << device_type
;
5519 } while ((next
= strtok (NULL
, ",")) != NULL
);
5521 free (device_types
);
5525 // Do not use CPU by default, this often reduces GPU performance because
5526 // the CPU is too busy to handle GPU synchronization
5528 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5531 return device_types_filter
;
5534 u32
get_random_num (const u32 min
, const u32 max
)
5536 if (min
== max
) return (min
);
5538 return ((rand () % (max
- min
)) + min
);
5541 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5543 u32 quotient
= dividend
/ divisor
;
5545 if (dividend
% divisor
) quotient
++;
5550 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5552 u64 quotient
= dividend
/ divisor
;
5554 if (dividend
% divisor
) quotient
++;
5559 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5561 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5562 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5564 if (tm
->tm_year
- 70)
5566 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5567 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5569 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5571 else if (tm
->tm_yday
)
5573 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5574 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5576 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5578 else if (tm
->tm_hour
)
5580 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5581 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5583 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5585 else if (tm
->tm_min
)
5587 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5588 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5590 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5594 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5596 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5600 void format_speed_display (float val
, char *buf
, size_t len
)
5611 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5622 /* generate output */
5626 snprintf (buf
, len
- 1, "%.0f ", val
);
5630 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5634 void lowercase (u8
*buf
, int len
)
5636 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5639 void uppercase (u8
*buf
, int len
)
5641 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5644 int fgetl (FILE *fp
, char *line_buf
)
5650 const int c
= fgetc (fp
);
5652 if (c
== EOF
) break;
5654 line_buf
[line_len
] = (char) c
;
5658 if (line_len
== HCBUFSIZ
) line_len
--;
5660 if (c
== '\n') break;
5663 if (line_len
== 0) return 0;
5665 if (line_buf
[line_len
- 1] == '\n')
5669 line_buf
[line_len
] = 0;
5672 if (line_len
== 0) return 0;
5674 if (line_buf
[line_len
- 1] == '\r')
5678 line_buf
[line_len
] = 0;
5684 int in_superchop (char *buf
)
5686 int len
= strlen (buf
);
5690 if (buf
[len
- 1] == '\n')
5697 if (buf
[len
- 1] == '\r')
5712 char **scan_directory (const char *path
)
5714 char *tmp_path
= mystrdup (path
);
5716 size_t tmp_path_len
= strlen (tmp_path
);
5718 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5720 tmp_path
[tmp_path_len
- 1] = 0;
5722 tmp_path_len
= strlen (tmp_path
);
5725 char **files
= NULL
;
5731 if ((d
= opendir (tmp_path
)) != NULL
)
5737 memset (&e
, 0, sizeof (e
));
5738 struct dirent
*de
= NULL
;
5740 if (readdir_r (d
, &e
, &de
) != 0)
5742 log_error ("ERROR: readdir_r() failed");
5747 if (de
== NULL
) break;
5751 while ((de
= readdir (d
)) != NULL
)
5754 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5756 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5758 char *path_file
= (char *) mymalloc (path_size
+ 1);
5760 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5762 path_file
[path_size
] = 0;
5766 if ((d_test
= opendir (path_file
)) != NULL
)
5774 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5778 files
[num_files
- 1] = path_file
;
5784 else if (errno
== ENOTDIR
)
5786 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5790 files
[num_files
- 1] = mystrdup (path
);
5793 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5797 files
[num_files
- 1] = NULL
;
5804 int count_dictionaries (char **dictionary_files
)
5806 if (dictionary_files
== NULL
) return 0;
5810 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5818 char *stroptitype (const uint opti_type
)
5822 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5823 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5824 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5825 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5826 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5827 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5828 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5829 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5830 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5831 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5832 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5833 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5834 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5835 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5836 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5837 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5838 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5839 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5840 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5846 char *strparser (const uint parser_status
)
5848 switch (parser_status
)
5850 case PARSER_OK
: return ((char *) PA_000
); break;
5851 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5852 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5853 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5854 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5855 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5856 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5857 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5858 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5859 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5860 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5861 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5862 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5863 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5864 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5865 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5866 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5869 return ((char *) PA_255
);
5872 char *strhashtype (const uint hash_mode
)
5876 case 0: return ((char *) HT_00000
); break;
5877 case 10: return ((char *) HT_00010
); break;
5878 case 11: return ((char *) HT_00011
); break;
5879 case 12: return ((char *) HT_00012
); break;
5880 case 20: return ((char *) HT_00020
); break;
5881 case 21: return ((char *) HT_00021
); break;
5882 case 22: return ((char *) HT_00022
); break;
5883 case 23: return ((char *) HT_00023
); break;
5884 case 30: return ((char *) HT_00030
); break;
5885 case 40: return ((char *) HT_00040
); break;
5886 case 50: return ((char *) HT_00050
); break;
5887 case 60: return ((char *) HT_00060
); break;
5888 case 100: return ((char *) HT_00100
); break;
5889 case 101: return ((char *) HT_00101
); break;
5890 case 110: return ((char *) HT_00110
); break;
5891 case 111: return ((char *) HT_00111
); break;
5892 case 112: return ((char *) HT_00112
); break;
5893 case 120: return ((char *) HT_00120
); break;
5894 case 121: return ((char *) HT_00121
); break;
5895 case 122: return ((char *) HT_00122
); break;
5896 case 124: return ((char *) HT_00124
); break;
5897 case 125: return ((char *) HT_00125
); break;
5898 case 130: return ((char *) HT_00130
); break;
5899 case 131: return ((char *) HT_00131
); break;
5900 case 132: return ((char *) HT_00132
); break;
5901 case 133: return ((char *) HT_00133
); break;
5902 case 140: return ((char *) HT_00140
); break;
5903 case 141: return ((char *) HT_00141
); break;
5904 case 150: return ((char *) HT_00150
); break;
5905 case 160: return ((char *) HT_00160
); break;
5906 case 200: return ((char *) HT_00200
); break;
5907 case 300: return ((char *) HT_00300
); break;
5908 case 400: return ((char *) HT_00400
); break;
5909 case 500: return ((char *) HT_00500
); break;
5910 case 501: return ((char *) HT_00501
); break;
5911 case 900: return ((char *) HT_00900
); break;
5912 case 910: return ((char *) HT_00910
); break;
5913 case 1000: return ((char *) HT_01000
); break;
5914 case 1100: return ((char *) HT_01100
); break;
5915 case 1400: return ((char *) HT_01400
); break;
5916 case 1410: return ((char *) HT_01410
); break;
5917 case 1420: return ((char *) HT_01420
); break;
5918 case 1421: return ((char *) HT_01421
); break;
5919 case 1430: return ((char *) HT_01430
); break;
5920 case 1440: return ((char *) HT_01440
); break;
5921 case 1441: return ((char *) HT_01441
); break;
5922 case 1450: return ((char *) HT_01450
); break;
5923 case 1460: return ((char *) HT_01460
); break;
5924 case 1500: return ((char *) HT_01500
); break;
5925 case 1600: return ((char *) HT_01600
); break;
5926 case 1700: return ((char *) HT_01700
); break;
5927 case 1710: return ((char *) HT_01710
); break;
5928 case 1711: return ((char *) HT_01711
); break;
5929 case 1720: return ((char *) HT_01720
); break;
5930 case 1722: return ((char *) HT_01722
); break;
5931 case 1730: return ((char *) HT_01730
); break;
5932 case 1731: return ((char *) HT_01731
); break;
5933 case 1740: return ((char *) HT_01740
); break;
5934 case 1750: return ((char *) HT_01750
); break;
5935 case 1760: return ((char *) HT_01760
); break;
5936 case 1800: return ((char *) HT_01800
); break;
5937 case 2100: return ((char *) HT_02100
); break;
5938 case 2400: return ((char *) HT_02400
); break;
5939 case 2410: return ((char *) HT_02410
); break;
5940 case 2500: return ((char *) HT_02500
); break;
5941 case 2600: return ((char *) HT_02600
); break;
5942 case 2611: return ((char *) HT_02611
); break;
5943 case 2612: return ((char *) HT_02612
); break;
5944 case 2711: return ((char *) HT_02711
); break;
5945 case 2811: return ((char *) HT_02811
); break;
5946 case 3000: return ((char *) HT_03000
); break;
5947 case 3100: return ((char *) HT_03100
); break;
5948 case 3200: return ((char *) HT_03200
); break;
5949 case 3710: return ((char *) HT_03710
); break;
5950 case 3711: return ((char *) HT_03711
); break;
5951 case 3800: return ((char *) HT_03800
); break;
5952 case 4300: return ((char *) HT_04300
); break;
5953 case 4400: return ((char *) HT_04400
); break;
5954 case 4500: return ((char *) HT_04500
); break;
5955 case 4700: return ((char *) HT_04700
); break;
5956 case 4800: return ((char *) HT_04800
); break;
5957 case 4900: return ((char *) HT_04900
); break;
5958 case 5000: return ((char *) HT_05000
); break;
5959 case 5100: return ((char *) HT_05100
); break;
5960 case 5200: return ((char *) HT_05200
); break;
5961 case 5300: return ((char *) HT_05300
); break;
5962 case 5400: return ((char *) HT_05400
); break;
5963 case 5500: return ((char *) HT_05500
); break;
5964 case 5600: return ((char *) HT_05600
); break;
5965 case 5700: return ((char *) HT_05700
); break;
5966 case 5800: return ((char *) HT_05800
); break;
5967 case 6000: return ((char *) HT_06000
); break;
5968 case 6100: return ((char *) HT_06100
); break;
5969 case 6211: return ((char *) HT_06211
); break;
5970 case 6212: return ((char *) HT_06212
); break;
5971 case 6213: return ((char *) HT_06213
); break;
5972 case 6221: return ((char *) HT_06221
); break;
5973 case 6222: return ((char *) HT_06222
); break;
5974 case 6223: return ((char *) HT_06223
); break;
5975 case 6231: return ((char *) HT_06231
); break;
5976 case 6232: return ((char *) HT_06232
); break;
5977 case 6233: return ((char *) HT_06233
); break;
5978 case 6241: return ((char *) HT_06241
); break;
5979 case 6242: return ((char *) HT_06242
); break;
5980 case 6243: return ((char *) HT_06243
); break;
5981 case 6300: return ((char *) HT_06300
); break;
5982 case 6400: return ((char *) HT_06400
); break;
5983 case 6500: return ((char *) HT_06500
); break;
5984 case 6600: return ((char *) HT_06600
); break;
5985 case 6700: return ((char *) HT_06700
); break;
5986 case 6800: return ((char *) HT_06800
); break;
5987 case 6900: return ((char *) HT_06900
); break;
5988 case 7100: return ((char *) HT_07100
); break;
5989 case 7200: return ((char *) HT_07200
); break;
5990 case 7300: return ((char *) HT_07300
); break;
5991 case 7400: return ((char *) HT_07400
); break;
5992 case 7500: return ((char *) HT_07500
); break;
5993 case 7600: return ((char *) HT_07600
); break;
5994 case 7700: return ((char *) HT_07700
); break;
5995 case 7800: return ((char *) HT_07800
); break;
5996 case 7900: return ((char *) HT_07900
); break;
5997 case 8000: return ((char *) HT_08000
); break;
5998 case 8100: return ((char *) HT_08100
); break;
5999 case 8200: return ((char *) HT_08200
); break;
6000 case 8300: return ((char *) HT_08300
); break;
6001 case 8400: return ((char *) HT_08400
); break;
6002 case 8500: return ((char *) HT_08500
); break;
6003 case 8600: return ((char *) HT_08600
); break;
6004 case 8700: return ((char *) HT_08700
); break;
6005 case 8800: return ((char *) HT_08800
); break;
6006 case 8900: return ((char *) HT_08900
); break;
6007 case 9000: return ((char *) HT_09000
); break;
6008 case 9100: return ((char *) HT_09100
); break;
6009 case 9200: return ((char *) HT_09200
); break;
6010 case 9300: return ((char *) HT_09300
); break;
6011 case 9400: return ((char *) HT_09400
); break;
6012 case 9500: return ((char *) HT_09500
); break;
6013 case 9600: return ((char *) HT_09600
); break;
6014 case 9700: return ((char *) HT_09700
); break;
6015 case 9710: return ((char *) HT_09710
); break;
6016 case 9720: return ((char *) HT_09720
); break;
6017 case 9800: return ((char *) HT_09800
); break;
6018 case 9810: return ((char *) HT_09810
); break;
6019 case 9820: return ((char *) HT_09820
); break;
6020 case 9900: return ((char *) HT_09900
); break;
6021 case 10000: return ((char *) HT_10000
); break;
6022 case 10100: return ((char *) HT_10100
); break;
6023 case 10200: return ((char *) HT_10200
); break;
6024 case 10300: return ((char *) HT_10300
); break;
6025 case 10400: return ((char *) HT_10400
); break;
6026 case 10410: return ((char *) HT_10410
); break;
6027 case 10420: return ((char *) HT_10420
); break;
6028 case 10500: return ((char *) HT_10500
); break;
6029 case 10600: return ((char *) HT_10600
); break;
6030 case 10700: return ((char *) HT_10700
); break;
6031 case 10800: return ((char *) HT_10800
); break;
6032 case 10900: return ((char *) HT_10900
); break;
6033 case 11000: return ((char *) HT_11000
); break;
6034 case 11100: return ((char *) HT_11100
); break;
6035 case 11200: return ((char *) HT_11200
); break;
6036 case 11300: return ((char *) HT_11300
); break;
6037 case 11400: return ((char *) HT_11400
); break;
6038 case 11500: return ((char *) HT_11500
); break;
6039 case 11600: return ((char *) HT_11600
); break;
6040 case 11700: return ((char *) HT_11700
); break;
6041 case 11800: return ((char *) HT_11800
); break;
6042 case 11900: return ((char *) HT_11900
); break;
6043 case 12000: return ((char *) HT_12000
); break;
6044 case 12100: return ((char *) HT_12100
); break;
6045 case 12200: return ((char *) HT_12200
); break;
6046 case 12300: return ((char *) HT_12300
); break;
6047 case 12400: return ((char *) HT_12400
); break;
6048 case 12500: return ((char *) HT_12500
); break;
6049 case 12600: return ((char *) HT_12600
); break;
6050 case 12700: return ((char *) HT_12700
); break;
6051 case 12800: return ((char *) HT_12800
); break;
6052 case 12900: return ((char *) HT_12900
); break;
6053 case 13000: return ((char *) HT_13000
); break;
6054 case 13100: return ((char *) HT_13100
); break;
6055 case 13200: return ((char *) HT_13200
); break;
6056 case 13300: return ((char *) HT_13300
); break;
6057 case 13400: return ((char *) HT_13400
); break;
6058 case 13500: return ((char *) HT_13500
); break;
6059 case 13600: return ((char *) HT_13600
); break;
6060 case 13711: return ((char *) HT_13711
); break;
6061 case 13712: return ((char *) HT_13712
); break;
6062 case 13713: return ((char *) HT_13713
); break;
6063 case 13721: return ((char *) HT_13721
); break;
6064 case 13722: return ((char *) HT_13722
); break;
6065 case 13723: return ((char *) HT_13723
); break;
6066 case 13731: return ((char *) HT_13731
); break;
6067 case 13732: return ((char *) HT_13732
); break;
6068 case 13733: return ((char *) HT_13733
); break;
6069 case 13741: return ((char *) HT_13741
); break;
6070 case 13742: return ((char *) HT_13742
); break;
6071 case 13743: return ((char *) HT_13743
); break;
6072 case 13751: return ((char *) HT_13751
); break;
6073 case 13752: return ((char *) HT_13752
); break;
6074 case 13753: return ((char *) HT_13753
); break;
6075 case 13761: return ((char *) HT_13761
); break;
6076 case 13762: return ((char *) HT_13762
); break;
6077 case 13763: return ((char *) HT_13763
); break;
6078 case 13800: return ((char *) HT_13800
); break;
6081 return ((char *) "Unknown");
6084 char *strstatus (const uint devices_status
)
6086 switch (devices_status
)
6088 case STATUS_INIT
: return ((char *) ST_0000
); break;
6089 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6090 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6091 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6092 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6093 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6094 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6095 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6096 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6097 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6098 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6101 return ((char *) "Unknown");
6104 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6106 uint hash_type
= data
.hash_type
;
6107 uint hash_mode
= data
.hash_mode
;
6108 uint salt_type
= data
.salt_type
;
6109 uint opts_type
= data
.opts_type
;
6110 uint opti_type
= data
.opti_type
;
6111 uint dgst_size
= data
.dgst_size
;
6113 char *hashfile
= data
.hashfile
;
6117 uint digest_buf
[64] = { 0 };
6119 u64
*digest_buf64
= (u64
*) digest_buf
;
6121 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6123 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6125 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6131 case HASH_TYPE_DESCRYPT
:
6132 FP (digest_buf
[1], digest_buf
[0], tt
);
6135 case HASH_TYPE_DESRACF
:
6136 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6137 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6139 FP (digest_buf
[1], digest_buf
[0], tt
);
6143 FP (digest_buf
[1], digest_buf
[0], tt
);
6146 case HASH_TYPE_NETNTLM
:
6147 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6148 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6149 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6150 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6152 FP (digest_buf
[1], digest_buf
[0], tt
);
6153 FP (digest_buf
[3], digest_buf
[2], tt
);
6156 case HASH_TYPE_BSDICRYPT
:
6157 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6158 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6160 FP (digest_buf
[1], digest_buf
[0], tt
);
6165 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6170 digest_buf
[0] += MD4M_A
;
6171 digest_buf
[1] += MD4M_B
;
6172 digest_buf
[2] += MD4M_C
;
6173 digest_buf
[3] += MD4M_D
;
6177 digest_buf
[0] += MD5M_A
;
6178 digest_buf
[1] += MD5M_B
;
6179 digest_buf
[2] += MD5M_C
;
6180 digest_buf
[3] += MD5M_D
;
6183 case HASH_TYPE_SHA1
:
6184 digest_buf
[0] += SHA1M_A
;
6185 digest_buf
[1] += SHA1M_B
;
6186 digest_buf
[2] += SHA1M_C
;
6187 digest_buf
[3] += SHA1M_D
;
6188 digest_buf
[4] += SHA1M_E
;
6191 case HASH_TYPE_SHA256
:
6192 digest_buf
[0] += SHA256M_A
;
6193 digest_buf
[1] += SHA256M_B
;
6194 digest_buf
[2] += SHA256M_C
;
6195 digest_buf
[3] += SHA256M_D
;
6196 digest_buf
[4] += SHA256M_E
;
6197 digest_buf
[5] += SHA256M_F
;
6198 digest_buf
[6] += SHA256M_G
;
6199 digest_buf
[7] += SHA256M_H
;
6202 case HASH_TYPE_SHA384
:
6203 digest_buf64
[0] += SHA384M_A
;
6204 digest_buf64
[1] += SHA384M_B
;
6205 digest_buf64
[2] += SHA384M_C
;
6206 digest_buf64
[3] += SHA384M_D
;
6207 digest_buf64
[4] += SHA384M_E
;
6208 digest_buf64
[5] += SHA384M_F
;
6209 digest_buf64
[6] += 0;
6210 digest_buf64
[7] += 0;
6213 case HASH_TYPE_SHA512
:
6214 digest_buf64
[0] += SHA512M_A
;
6215 digest_buf64
[1] += SHA512M_B
;
6216 digest_buf64
[2] += SHA512M_C
;
6217 digest_buf64
[3] += SHA512M_D
;
6218 digest_buf64
[4] += SHA512M_E
;
6219 digest_buf64
[5] += SHA512M_F
;
6220 digest_buf64
[6] += SHA512M_G
;
6221 digest_buf64
[7] += SHA512M_H
;
6226 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6228 if (dgst_size
== DGST_SIZE_4_2
)
6230 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6232 else if (dgst_size
== DGST_SIZE_4_4
)
6234 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6236 else if (dgst_size
== DGST_SIZE_4_5
)
6238 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6240 else if (dgst_size
== DGST_SIZE_4_6
)
6242 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6244 else if (dgst_size
== DGST_SIZE_4_8
)
6246 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6248 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6250 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6252 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6254 else if (hash_type
== HASH_TYPE_SHA384
)
6256 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6258 else if (hash_type
== HASH_TYPE_SHA512
)
6260 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6262 else if (hash_type
== HASH_TYPE_GOST
)
6264 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6267 else if (dgst_size
== DGST_SIZE_4_64
)
6269 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6271 else if (dgst_size
== DGST_SIZE_8_25
)
6273 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6277 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6278 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6279 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6285 memset (&salt
, 0, sizeof (salt_t
));
6287 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6289 char *ptr
= (char *) salt
.salt_buf
;
6291 uint len
= salt
.salt_len
;
6293 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6299 case HASH_TYPE_NETNTLM
:
6301 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6302 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6304 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6310 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6312 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6320 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6322 uint max
= salt
.salt_len
/ 4;
6326 for (uint i
= 0; i
< max
; i
++)
6328 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6332 if (opts_type
& OPTS_TYPE_ST_HEX
)
6334 char tmp
[64] = { 0 };
6336 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6338 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6343 memcpy (ptr
, tmp
, len
);
6346 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6348 memset (ptr
+ len
, 0, memset_size
);
6350 salt
.salt_len
= len
;
6354 // some modes require special encoding
6357 uint out_buf_plain
[256] = { 0 };
6358 uint out_buf_salt
[256] = { 0 };
6360 char tmp_buf
[1024] = { 0 };
6362 char *ptr_plain
= (char *) out_buf_plain
;
6363 char *ptr_salt
= (char *) out_buf_salt
;
6365 if (hash_mode
== 22)
6367 char username
[30] = { 0 };
6369 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6371 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6373 u16
*ptr
= (u16
*) digest_buf
;
6375 tmp_buf
[ 0] = sig
[0];
6376 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6377 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6378 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6379 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6380 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6381 tmp_buf
[ 6] = sig
[1];
6382 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6383 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6384 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6385 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6386 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6387 tmp_buf
[12] = sig
[2];
6388 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6389 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6390 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6391 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6392 tmp_buf
[17] = sig
[3];
6393 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6394 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6395 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6396 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6397 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6398 tmp_buf
[23] = sig
[4];
6399 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6400 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6401 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6402 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6403 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6404 tmp_buf
[29] = sig
[5];
6406 snprintf (out_buf
, len
-1, "%s:%s",
6410 else if (hash_mode
== 23)
6412 // do not show the skyper part in output
6414 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6416 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6418 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6425 else if (hash_mode
== 101)
6427 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6429 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6430 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6431 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6432 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6433 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6435 memcpy (tmp_buf
, digest_buf
, 20);
6437 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6439 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6441 else if (hash_mode
== 111)
6443 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6445 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6446 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6447 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6448 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6449 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6451 memcpy (tmp_buf
, digest_buf
, 20);
6452 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6454 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6456 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6458 else if ((hash_mode
== 122) || (hash_mode
== 125))
6460 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6461 (char *) salt
.salt_buf
,
6468 else if (hash_mode
== 124)
6470 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6471 (char *) salt
.salt_buf
,
6478 else if (hash_mode
== 131)
6480 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6481 (char *) salt
.salt_buf
,
6489 else if (hash_mode
== 132)
6491 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6492 (char *) salt
.salt_buf
,
6499 else if (hash_mode
== 133)
6501 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6503 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6504 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6505 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6506 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6507 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6509 memcpy (tmp_buf
, digest_buf
, 20);
6511 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6513 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6515 else if (hash_mode
== 141)
6517 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6519 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6521 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6523 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6525 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6526 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6527 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6528 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6529 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6531 memcpy (tmp_buf
, digest_buf
, 20);
6533 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6537 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6539 else if (hash_mode
== 400)
6541 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6543 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6544 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6545 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6546 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6548 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6550 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6552 else if (hash_mode
== 500)
6554 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6556 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6557 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6558 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6559 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6561 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6563 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6565 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6569 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6572 else if (hash_mode
== 501)
6574 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6576 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6577 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6579 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6581 else if (hash_mode
== 1421)
6583 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6585 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6601 else if (hash_mode
== 1441)
6603 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6605 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6607 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6609 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6611 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6612 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6613 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6614 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6615 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6616 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6617 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6618 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6620 memcpy (tmp_buf
, digest_buf
, 32);
6622 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6626 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6628 else if (hash_mode
== 1500)
6630 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6631 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6632 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6633 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6634 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6636 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6638 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6640 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6641 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6643 memcpy (tmp_buf
, digest_buf
, 8);
6645 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6647 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6651 else if (hash_mode
== 1600)
6653 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6655 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6656 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6657 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6658 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6660 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6662 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6664 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6668 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6671 else if (hash_mode
== 1711)
6673 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6675 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6676 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6677 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6678 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6679 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6680 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6681 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6682 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6684 memcpy (tmp_buf
, digest_buf
, 64);
6685 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6687 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6689 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6691 else if (hash_mode
== 1722)
6693 uint
*ptr
= digest_buf
;
6695 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6696 (unsigned char *) salt
.salt_buf
,
6706 else if (hash_mode
== 1731)
6708 uint
*ptr
= digest_buf
;
6710 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6711 (unsigned char *) salt
.salt_buf
,
6721 else if (hash_mode
== 1800)
6725 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6726 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6727 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6728 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6729 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6730 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6731 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6732 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6734 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6736 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6738 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6742 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6745 else if (hash_mode
== 2100)
6749 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6751 salt
.salt_iter
+ 1);
6753 uint signature_len
= strlen (out_buf
);
6755 pos
+= signature_len
;
6756 len
-= signature_len
;
6758 char *salt_ptr
= (char *) salt
.salt_buf
;
6760 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6762 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6763 byte_swap_32 (digest_buf
[0]),
6764 byte_swap_32 (digest_buf
[1]),
6765 byte_swap_32 (digest_buf
[2]),
6766 byte_swap_32 (digest_buf
[3]));
6768 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6770 memcpy (tmp_buf
, digest_buf
, 16);
6772 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6774 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6775 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6776 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6777 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6779 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6780 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6781 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6782 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6784 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6785 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6786 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6787 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6789 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6790 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6791 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6792 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6794 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6795 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6796 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6797 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6801 else if (hash_mode
== 2500)
6803 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6805 wpa_t
*wpa
= &wpas
[salt_pos
];
6807 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6808 (char *) salt
.salt_buf
,
6822 else if (hash_mode
== 4400)
6824 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6825 byte_swap_32 (digest_buf
[0]),
6826 byte_swap_32 (digest_buf
[1]),
6827 byte_swap_32 (digest_buf
[2]),
6828 byte_swap_32 (digest_buf
[3]));
6830 else if (hash_mode
== 4700)
6832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6833 byte_swap_32 (digest_buf
[0]),
6834 byte_swap_32 (digest_buf
[1]),
6835 byte_swap_32 (digest_buf
[2]),
6836 byte_swap_32 (digest_buf
[3]),
6837 byte_swap_32 (digest_buf
[4]));
6839 else if (hash_mode
== 4800)
6841 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6843 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6848 byte_swap_32 (salt
.salt_buf
[0]),
6849 byte_swap_32 (salt
.salt_buf
[1]),
6850 byte_swap_32 (salt
.salt_buf
[2]),
6851 byte_swap_32 (salt
.salt_buf
[3]),
6854 else if (hash_mode
== 4900)
6856 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6857 byte_swap_32 (digest_buf
[0]),
6858 byte_swap_32 (digest_buf
[1]),
6859 byte_swap_32 (digest_buf
[2]),
6860 byte_swap_32 (digest_buf
[3]),
6861 byte_swap_32 (digest_buf
[4]));
6863 else if (hash_mode
== 5100)
6865 snprintf (out_buf
, len
-1, "%08x%08x",
6869 else if (hash_mode
== 5200)
6871 snprintf (out_buf
, len
-1, "%s", hashfile
);
6873 else if (hash_mode
== 5300)
6875 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6877 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6879 int buf_len
= len
-1;
6883 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6885 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6887 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6889 snprintf (out_buf
, buf_len
, ":");
6895 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6903 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6905 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6907 if ((i
== 0) || (i
== 5))
6909 snprintf (out_buf
, buf_len
, ":");
6915 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6923 for (uint i
= 0; i
< 4; i
++)
6927 snprintf (out_buf
, buf_len
, ":");
6933 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6939 else if (hash_mode
== 5400)
6941 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6943 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6945 int buf_len
= len
-1;
6949 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6951 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6953 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6955 snprintf (out_buf
, buf_len
, ":");
6961 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6969 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6971 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6973 if ((i
== 0) || (i
== 5))
6975 snprintf (out_buf
, buf_len
, ":");
6981 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6989 for (uint i
= 0; i
< 5; i
++)
6993 snprintf (out_buf
, buf_len
, ":");
6999 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7005 else if (hash_mode
== 5500)
7007 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7009 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7011 char user_buf
[64] = { 0 };
7012 char domain_buf
[64] = { 0 };
7013 char srvchall_buf
[1024] = { 0 };
7014 char clichall_buf
[1024] = { 0 };
7016 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7018 char *ptr
= (char *) netntlm
->userdomain_buf
;
7020 user_buf
[i
] = ptr
[j
];
7023 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7025 char *ptr
= (char *) netntlm
->userdomain_buf
;
7027 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7030 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7032 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7034 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7037 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7039 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7041 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7044 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7052 byte_swap_32 (salt
.salt_buf_pc
[0]),
7053 byte_swap_32 (salt
.salt_buf_pc
[1]),
7056 else if (hash_mode
== 5600)
7058 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7060 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7062 char user_buf
[64] = { 0 };
7063 char domain_buf
[64] = { 0 };
7064 char srvchall_buf
[1024] = { 0 };
7065 char clichall_buf
[1024] = { 0 };
7067 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7069 char *ptr
= (char *) netntlm
->userdomain_buf
;
7071 user_buf
[i
] = ptr
[j
];
7074 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7076 char *ptr
= (char *) netntlm
->userdomain_buf
;
7078 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7081 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7083 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7085 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7088 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7090 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7092 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7095 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7105 else if (hash_mode
== 5700)
7107 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7109 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7110 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7111 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7112 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7113 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7114 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7115 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7116 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7118 memcpy (tmp_buf
, digest_buf
, 32);
7120 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7124 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7126 else if (hash_mode
== 5800)
7128 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7129 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7130 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7131 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7132 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7134 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7141 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7143 snprintf (out_buf
, len
-1, "%s", hashfile
);
7145 else if (hash_mode
== 6300)
7147 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7149 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7150 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7151 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7152 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7154 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7156 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7158 else if (hash_mode
== 6400)
7160 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7162 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7164 else if (hash_mode
== 6500)
7166 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7168 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7170 else if (hash_mode
== 6600)
7172 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7174 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7176 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7177 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7179 uint buf_len
= len
- 1;
7181 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7184 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7186 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7191 else if (hash_mode
== 6700)
7193 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7195 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7197 else if (hash_mode
== 6800)
7199 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7201 else if (hash_mode
== 7100)
7203 uint
*ptr
= digest_buf
;
7205 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7207 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7209 uint esalt
[8] = { 0 };
7211 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7212 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7213 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7214 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7215 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7216 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7217 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7218 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7220 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7221 SIGNATURE_SHA512OSX
,
7223 esalt
[ 0], esalt
[ 1],
7224 esalt
[ 2], esalt
[ 3],
7225 esalt
[ 4], esalt
[ 5],
7226 esalt
[ 6], esalt
[ 7],
7234 ptr
[15], ptr
[14]);
7236 else if (hash_mode
== 7200)
7238 uint
*ptr
= digest_buf
;
7240 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7242 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7246 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7248 len_used
= strlen (out_buf
);
7250 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7252 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7254 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7257 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7265 ptr
[15], ptr
[14]);
7267 else if (hash_mode
== 7300)
7269 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7271 rakp_t
*rakp
= &rakps
[salt_pos
];
7273 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7275 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7278 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7285 else if (hash_mode
== 7400)
7287 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7289 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7290 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7291 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7292 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7293 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7294 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7295 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7296 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7298 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7300 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7302 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7306 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7309 else if (hash_mode
== 7500)
7311 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7313 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7315 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7316 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7318 char data
[128] = { 0 };
7320 char *ptr_data
= data
;
7322 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7324 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7327 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7329 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7334 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7336 (char *) krb5pa
->user
,
7337 (char *) krb5pa
->realm
,
7338 (char *) krb5pa
->salt
,
7341 else if (hash_mode
== 7700)
7343 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7344 (char *) salt
.salt_buf
,
7348 else if (hash_mode
== 7800)
7350 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7351 (char *) salt
.salt_buf
,
7358 else if (hash_mode
== 7900)
7360 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7364 char *tmp
= (char *) salt
.salt_buf_pc
;
7366 ptr_plain
[42] = tmp
[0];
7372 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7374 else if (hash_mode
== 8000)
7376 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7377 (unsigned char *) salt
.salt_buf
,
7387 else if (hash_mode
== 8100)
7389 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7390 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7392 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7393 (unsigned char *) salt
.salt_buf
,
7400 else if (hash_mode
== 8200)
7402 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7404 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7406 char data_buf
[4096] = { 0 };
7408 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7410 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7413 data_buf
[cloudkey
->data_len
* 2] = 0;
7415 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7416 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7417 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7418 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7419 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7420 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7421 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7422 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7424 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7425 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7426 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7427 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7429 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7445 else if (hash_mode
== 8300)
7447 char digest_buf_c
[34] = { 0 };
7449 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7450 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7451 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7452 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7453 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7455 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7457 digest_buf_c
[32] = 0;
7461 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7463 char domain_buf_c
[33] = { 0 };
7465 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7467 for (uint i
= 0; i
< salt_pc_len
; i
++)
7469 const char next
= domain_buf_c
[i
];
7471 domain_buf_c
[i
] = '.';
7476 domain_buf_c
[salt_pc_len
] = 0;
7480 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7482 else if (hash_mode
== 8500)
7484 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7486 else if (hash_mode
== 2612)
7488 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7490 (char *) salt
.salt_buf
,
7496 else if (hash_mode
== 3711)
7498 char *salt_ptr
= (char *) salt
.salt_buf
;
7500 salt_ptr
[salt
.salt_len
- 1] = 0;
7502 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7503 SIGNATURE_MEDIAWIKI_B
,
7510 else if (hash_mode
== 8800)
7512 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7514 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7516 char tmp
[3073] = { 0 };
7518 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7520 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7525 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7526 SIGNATURE_ANDROIDFDE
,
7527 byte_swap_32 (salt
.salt_buf
[0]),
7528 byte_swap_32 (salt
.salt_buf
[1]),
7529 byte_swap_32 (salt
.salt_buf
[2]),
7530 byte_swap_32 (salt
.salt_buf
[3]),
7531 byte_swap_32 (digest_buf
[0]),
7532 byte_swap_32 (digest_buf
[1]),
7533 byte_swap_32 (digest_buf
[2]),
7534 byte_swap_32 (digest_buf
[3]),
7537 else if (hash_mode
== 8900)
7539 uint N
= salt
.scrypt_N
;
7540 uint r
= salt
.scrypt_r
;
7541 uint p
= salt
.scrypt_p
;
7543 char base64_salt
[32] = { 0 };
7545 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7547 memset (tmp_buf
, 0, 46);
7549 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7550 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7551 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7552 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7553 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7554 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7555 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7556 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7557 digest_buf
[8] = 0; // needed for base64_encode ()
7559 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7561 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7569 else if (hash_mode
== 9000)
7571 snprintf (out_buf
, len
-1, "%s", hashfile
);
7573 else if (hash_mode
== 9200)
7577 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7579 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7581 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7585 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7586 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7587 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7588 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7589 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7590 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7591 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7592 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7593 digest_buf
[8] = 0; // needed for base64_encode ()
7595 char tmp_buf
[64] = { 0 };
7597 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7598 tmp_buf
[43] = 0; // cut it here
7602 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7604 else if (hash_mode
== 9300)
7606 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7607 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7608 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7609 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7610 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7611 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7612 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7613 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7614 digest_buf
[8] = 0; // needed for base64_encode ()
7616 char tmp_buf
[64] = { 0 };
7618 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7619 tmp_buf
[43] = 0; // cut it here
7621 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7623 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7625 else if (hash_mode
== 9400)
7627 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7629 office2007_t
*office2007
= &office2007s
[salt_pos
];
7631 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7632 SIGNATURE_OFFICE2007
,
7635 office2007
->keySize
,
7641 office2007
->encryptedVerifier
[0],
7642 office2007
->encryptedVerifier
[1],
7643 office2007
->encryptedVerifier
[2],
7644 office2007
->encryptedVerifier
[3],
7645 office2007
->encryptedVerifierHash
[0],
7646 office2007
->encryptedVerifierHash
[1],
7647 office2007
->encryptedVerifierHash
[2],
7648 office2007
->encryptedVerifierHash
[3],
7649 office2007
->encryptedVerifierHash
[4]);
7651 else if (hash_mode
== 9500)
7653 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7655 office2010_t
*office2010
= &office2010s
[salt_pos
];
7657 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7663 office2010
->encryptedVerifier
[0],
7664 office2010
->encryptedVerifier
[1],
7665 office2010
->encryptedVerifier
[2],
7666 office2010
->encryptedVerifier
[3],
7667 office2010
->encryptedVerifierHash
[0],
7668 office2010
->encryptedVerifierHash
[1],
7669 office2010
->encryptedVerifierHash
[2],
7670 office2010
->encryptedVerifierHash
[3],
7671 office2010
->encryptedVerifierHash
[4],
7672 office2010
->encryptedVerifierHash
[5],
7673 office2010
->encryptedVerifierHash
[6],
7674 office2010
->encryptedVerifierHash
[7]);
7676 else if (hash_mode
== 9600)
7678 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7680 office2013_t
*office2013
= &office2013s
[salt_pos
];
7682 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7688 office2013
->encryptedVerifier
[0],
7689 office2013
->encryptedVerifier
[1],
7690 office2013
->encryptedVerifier
[2],
7691 office2013
->encryptedVerifier
[3],
7692 office2013
->encryptedVerifierHash
[0],
7693 office2013
->encryptedVerifierHash
[1],
7694 office2013
->encryptedVerifierHash
[2],
7695 office2013
->encryptedVerifierHash
[3],
7696 office2013
->encryptedVerifierHash
[4],
7697 office2013
->encryptedVerifierHash
[5],
7698 office2013
->encryptedVerifierHash
[6],
7699 office2013
->encryptedVerifierHash
[7]);
7701 else if (hash_mode
== 9700)
7703 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7705 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7707 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7708 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7709 byte_swap_32 (salt
.salt_buf
[0]),
7710 byte_swap_32 (salt
.salt_buf
[1]),
7711 byte_swap_32 (salt
.salt_buf
[2]),
7712 byte_swap_32 (salt
.salt_buf
[3]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7722 else if (hash_mode
== 9710)
7724 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7726 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7728 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7729 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7730 byte_swap_32 (salt
.salt_buf
[0]),
7731 byte_swap_32 (salt
.salt_buf
[1]),
7732 byte_swap_32 (salt
.salt_buf
[2]),
7733 byte_swap_32 (salt
.salt_buf
[3]),
7734 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7735 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7736 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7737 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7738 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7739 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7743 else if (hash_mode
== 9720)
7745 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7747 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7749 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7751 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7752 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7753 byte_swap_32 (salt
.salt_buf
[0]),
7754 byte_swap_32 (salt
.salt_buf
[1]),
7755 byte_swap_32 (salt
.salt_buf
[2]),
7756 byte_swap_32 (salt
.salt_buf
[3]),
7757 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7758 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7759 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7760 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7761 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7762 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7771 else if (hash_mode
== 9800)
7773 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7775 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7777 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7778 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7783 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7793 else if (hash_mode
== 9810)
7795 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7797 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7799 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7800 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7805 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7806 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7807 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7808 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7809 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7810 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7811 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7815 else if (hash_mode
== 9820)
7817 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7819 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7821 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7823 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7824 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7829 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7830 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7831 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7832 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7833 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7844 else if (hash_mode
== 10000)
7848 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7850 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7852 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7856 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7857 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7858 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7859 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7860 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7861 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7862 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7863 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7864 digest_buf
[8] = 0; // needed for base64_encode ()
7866 char tmp_buf
[64] = { 0 };
7868 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7872 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7874 else if (hash_mode
== 10100)
7876 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7881 byte_swap_32 (salt
.salt_buf
[0]),
7882 byte_swap_32 (salt
.salt_buf
[1]),
7883 byte_swap_32 (salt
.salt_buf
[2]),
7884 byte_swap_32 (salt
.salt_buf
[3]));
7886 else if (hash_mode
== 10200)
7888 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7890 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7894 char challenge
[100] = { 0 };
7896 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7900 char tmp_buf
[100] = { 0 };
7902 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7903 (char *) cram_md5
->user
,
7909 char response
[100] = { 0 };
7911 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7913 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7915 else if (hash_mode
== 10300)
7917 char tmp_buf
[100] = { 0 };
7919 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7920 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7922 uint tmp_len
= 20 + salt
.salt_len
;
7926 char base64_encoded
[100] = { 0 };
7928 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7930 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7932 else if (hash_mode
== 10400)
7934 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7936 pdf_t
*pdf
= &pdfs
[salt_pos
];
7938 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7946 byte_swap_32 (pdf
->id_buf
[0]),
7947 byte_swap_32 (pdf
->id_buf
[1]),
7948 byte_swap_32 (pdf
->id_buf
[2]),
7949 byte_swap_32 (pdf
->id_buf
[3]),
7951 byte_swap_32 (pdf
->u_buf
[0]),
7952 byte_swap_32 (pdf
->u_buf
[1]),
7953 byte_swap_32 (pdf
->u_buf
[2]),
7954 byte_swap_32 (pdf
->u_buf
[3]),
7955 byte_swap_32 (pdf
->u_buf
[4]),
7956 byte_swap_32 (pdf
->u_buf
[5]),
7957 byte_swap_32 (pdf
->u_buf
[6]),
7958 byte_swap_32 (pdf
->u_buf
[7]),
7960 byte_swap_32 (pdf
->o_buf
[0]),
7961 byte_swap_32 (pdf
->o_buf
[1]),
7962 byte_swap_32 (pdf
->o_buf
[2]),
7963 byte_swap_32 (pdf
->o_buf
[3]),
7964 byte_swap_32 (pdf
->o_buf
[4]),
7965 byte_swap_32 (pdf
->o_buf
[5]),
7966 byte_swap_32 (pdf
->o_buf
[6]),
7967 byte_swap_32 (pdf
->o_buf
[7])
7970 else if (hash_mode
== 10410)
7972 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7974 pdf_t
*pdf
= &pdfs
[salt_pos
];
7976 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7984 byte_swap_32 (pdf
->id_buf
[0]),
7985 byte_swap_32 (pdf
->id_buf
[1]),
7986 byte_swap_32 (pdf
->id_buf
[2]),
7987 byte_swap_32 (pdf
->id_buf
[3]),
7989 byte_swap_32 (pdf
->u_buf
[0]),
7990 byte_swap_32 (pdf
->u_buf
[1]),
7991 byte_swap_32 (pdf
->u_buf
[2]),
7992 byte_swap_32 (pdf
->u_buf
[3]),
7993 byte_swap_32 (pdf
->u_buf
[4]),
7994 byte_swap_32 (pdf
->u_buf
[5]),
7995 byte_swap_32 (pdf
->u_buf
[6]),
7996 byte_swap_32 (pdf
->u_buf
[7]),
7998 byte_swap_32 (pdf
->o_buf
[0]),
7999 byte_swap_32 (pdf
->o_buf
[1]),
8000 byte_swap_32 (pdf
->o_buf
[2]),
8001 byte_swap_32 (pdf
->o_buf
[3]),
8002 byte_swap_32 (pdf
->o_buf
[4]),
8003 byte_swap_32 (pdf
->o_buf
[5]),
8004 byte_swap_32 (pdf
->o_buf
[6]),
8005 byte_swap_32 (pdf
->o_buf
[7])
8008 else if (hash_mode
== 10420)
8010 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8012 pdf_t
*pdf
= &pdfs
[salt_pos
];
8014 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8016 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
8024 byte_swap_32 (pdf
->id_buf
[0]),
8025 byte_swap_32 (pdf
->id_buf
[1]),
8026 byte_swap_32 (pdf
->id_buf
[2]),
8027 byte_swap_32 (pdf
->id_buf
[3]),
8029 byte_swap_32 (pdf
->u_buf
[0]),
8030 byte_swap_32 (pdf
->u_buf
[1]),
8031 byte_swap_32 (pdf
->u_buf
[2]),
8032 byte_swap_32 (pdf
->u_buf
[3]),
8033 byte_swap_32 (pdf
->u_buf
[4]),
8034 byte_swap_32 (pdf
->u_buf
[5]),
8035 byte_swap_32 (pdf
->u_buf
[6]),
8036 byte_swap_32 (pdf
->u_buf
[7]),
8038 byte_swap_32 (pdf
->o_buf
[0]),
8039 byte_swap_32 (pdf
->o_buf
[1]),
8040 byte_swap_32 (pdf
->o_buf
[2]),
8041 byte_swap_32 (pdf
->o_buf
[3]),
8042 byte_swap_32 (pdf
->o_buf
[4]),
8043 byte_swap_32 (pdf
->o_buf
[5]),
8044 byte_swap_32 (pdf
->o_buf
[6]),
8045 byte_swap_32 (pdf
->o_buf
[7]),
8053 else if (hash_mode
== 10500)
8055 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8057 pdf_t
*pdf
= &pdfs
[salt_pos
];
8059 if (pdf
->id_len
== 32)
8061 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8069 byte_swap_32 (pdf
->id_buf
[0]),
8070 byte_swap_32 (pdf
->id_buf
[1]),
8071 byte_swap_32 (pdf
->id_buf
[2]),
8072 byte_swap_32 (pdf
->id_buf
[3]),
8073 byte_swap_32 (pdf
->id_buf
[4]),
8074 byte_swap_32 (pdf
->id_buf
[5]),
8075 byte_swap_32 (pdf
->id_buf
[6]),
8076 byte_swap_32 (pdf
->id_buf
[7]),
8078 byte_swap_32 (pdf
->u_buf
[0]),
8079 byte_swap_32 (pdf
->u_buf
[1]),
8080 byte_swap_32 (pdf
->u_buf
[2]),
8081 byte_swap_32 (pdf
->u_buf
[3]),
8082 byte_swap_32 (pdf
->u_buf
[4]),
8083 byte_swap_32 (pdf
->u_buf
[5]),
8084 byte_swap_32 (pdf
->u_buf
[6]),
8085 byte_swap_32 (pdf
->u_buf
[7]),
8087 byte_swap_32 (pdf
->o_buf
[0]),
8088 byte_swap_32 (pdf
->o_buf
[1]),
8089 byte_swap_32 (pdf
->o_buf
[2]),
8090 byte_swap_32 (pdf
->o_buf
[3]),
8091 byte_swap_32 (pdf
->o_buf
[4]),
8092 byte_swap_32 (pdf
->o_buf
[5]),
8093 byte_swap_32 (pdf
->o_buf
[6]),
8094 byte_swap_32 (pdf
->o_buf
[7])
8099 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8107 byte_swap_32 (pdf
->id_buf
[0]),
8108 byte_swap_32 (pdf
->id_buf
[1]),
8109 byte_swap_32 (pdf
->id_buf
[2]),
8110 byte_swap_32 (pdf
->id_buf
[3]),
8112 byte_swap_32 (pdf
->u_buf
[0]),
8113 byte_swap_32 (pdf
->u_buf
[1]),
8114 byte_swap_32 (pdf
->u_buf
[2]),
8115 byte_swap_32 (pdf
->u_buf
[3]),
8116 byte_swap_32 (pdf
->u_buf
[4]),
8117 byte_swap_32 (pdf
->u_buf
[5]),
8118 byte_swap_32 (pdf
->u_buf
[6]),
8119 byte_swap_32 (pdf
->u_buf
[7]),
8121 byte_swap_32 (pdf
->o_buf
[0]),
8122 byte_swap_32 (pdf
->o_buf
[1]),
8123 byte_swap_32 (pdf
->o_buf
[2]),
8124 byte_swap_32 (pdf
->o_buf
[3]),
8125 byte_swap_32 (pdf
->o_buf
[4]),
8126 byte_swap_32 (pdf
->o_buf
[5]),
8127 byte_swap_32 (pdf
->o_buf
[6]),
8128 byte_swap_32 (pdf
->o_buf
[7])
8132 else if (hash_mode
== 10600)
8134 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8136 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8137 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8139 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8141 else if (hash_mode
== 10700)
8143 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8145 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8146 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8148 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8150 else if (hash_mode
== 10900)
8152 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8154 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8155 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8157 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8159 else if (hash_mode
== 11100)
8161 u32 salt_challenge
= salt
.salt_buf
[0];
8163 salt_challenge
= byte_swap_32 (salt_challenge
);
8165 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8167 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8168 SIGNATURE_POSTGRESQL_AUTH
,
8176 else if (hash_mode
== 11200)
8178 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8179 SIGNATURE_MYSQL_AUTH
,
8180 (unsigned char *) salt
.salt_buf
,
8187 else if (hash_mode
== 11300)
8189 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8191 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8193 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8194 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8195 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8197 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8198 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8199 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8201 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8203 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8205 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8208 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8210 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8212 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8215 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8217 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8219 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8222 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8223 SIGNATURE_BITCOIN_WALLET
,
8227 (unsigned char *) salt
.salt_buf
,
8235 free (cry_master_buf
);
8237 free (public_key_buf
);
8239 else if (hash_mode
== 11400)
8241 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8243 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8244 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8246 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8248 else if (hash_mode
== 11600)
8250 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8252 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8254 const uint data_len
= seven_zip
->data_len
;
8256 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8258 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8260 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8262 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8265 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8266 SIGNATURE_SEVEN_ZIP
,
8270 (char *) seven_zip
->salt_buf
,
8272 seven_zip
->iv_buf
[0],
8273 seven_zip
->iv_buf
[1],
8274 seven_zip
->iv_buf
[2],
8275 seven_zip
->iv_buf
[3],
8277 seven_zip
->data_len
,
8278 seven_zip
->unpack_size
,
8283 else if (hash_mode
== 11700)
8285 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8295 else if (hash_mode
== 11800)
8297 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8315 else if (hash_mode
== 11900)
8317 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8319 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8320 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8322 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8324 else if (hash_mode
== 12000)
8326 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8328 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8329 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8331 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8333 else if (hash_mode
== 12100)
8335 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8337 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8338 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8340 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8342 else if (hash_mode
== 12200)
8344 uint
*ptr_digest
= digest_buf
;
8345 uint
*ptr_salt
= salt
.salt_buf
;
8347 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8354 else if (hash_mode
== 12300)
8356 uint
*ptr_digest
= digest_buf
;
8357 uint
*ptr_salt
= salt
.salt_buf
;
8359 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
8360 ptr_digest
[ 0], ptr_digest
[ 1],
8361 ptr_digest
[ 2], ptr_digest
[ 3],
8362 ptr_digest
[ 4], ptr_digest
[ 5],
8363 ptr_digest
[ 6], ptr_digest
[ 7],
8364 ptr_digest
[ 8], ptr_digest
[ 9],
8365 ptr_digest
[10], ptr_digest
[11],
8366 ptr_digest
[12], ptr_digest
[13],
8367 ptr_digest
[14], ptr_digest
[15],
8373 else if (hash_mode
== 12400)
8375 // encode iteration count
8377 char salt_iter
[5] = { 0 };
8379 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8380 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8381 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8382 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8387 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8388 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8389 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8390 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8395 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8397 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8398 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8400 memcpy (tmp_buf
, digest_buf
, 8);
8402 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8406 // fill the resulting buffer
8408 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8410 else if (hash_mode
== 12500)
8412 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8414 byte_swap_32 (salt
.salt_buf
[0]),
8415 byte_swap_32 (salt
.salt_buf
[1]),
8421 else if (hash_mode
== 12600)
8423 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8424 digest_buf
[0] + salt
.salt_buf_pc
[0],
8425 digest_buf
[1] + salt
.salt_buf_pc
[1],
8426 digest_buf
[2] + salt
.salt_buf_pc
[2],
8427 digest_buf
[3] + salt
.salt_buf_pc
[3],
8428 digest_buf
[4] + salt
.salt_buf_pc
[4],
8429 digest_buf
[5] + salt
.salt_buf_pc
[5],
8430 digest_buf
[6] + salt
.salt_buf_pc
[6],
8431 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8433 else if (hash_mode
== 12700)
8435 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8437 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8438 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8440 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8442 else if (hash_mode
== 12800)
8444 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8446 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8459 byte_swap_32 (digest_buf
[0]),
8460 byte_swap_32 (digest_buf
[1]),
8461 byte_swap_32 (digest_buf
[2]),
8462 byte_swap_32 (digest_buf
[3]),
8463 byte_swap_32 (digest_buf
[4]),
8464 byte_swap_32 (digest_buf
[5]),
8465 byte_swap_32 (digest_buf
[6]),
8466 byte_swap_32 (digest_buf
[7])
8469 else if (hash_mode
== 12900)
8471 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8480 byte_swap_32 (digest_buf
[0]),
8481 byte_swap_32 (digest_buf
[1]),
8482 byte_swap_32 (digest_buf
[2]),
8483 byte_swap_32 (digest_buf
[3]),
8484 byte_swap_32 (digest_buf
[4]),
8485 byte_swap_32 (digest_buf
[5]),
8486 byte_swap_32 (digest_buf
[6]),
8487 byte_swap_32 (digest_buf
[7]),
8494 else if (hash_mode
== 13000)
8496 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8498 rar5_t
*rar5
= &rar5s
[salt_pos
];
8500 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8510 byte_swap_32 (digest_buf
[0]),
8511 byte_swap_32 (digest_buf
[1])
8514 else if (hash_mode
== 13100)
8516 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8518 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8520 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8521 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8523 char data
[2560 * 4 * 2] = { 0 };
8525 char *ptr_data
= data
;
8527 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8528 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8533 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8534 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8536 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8538 (char *) krb5tgs
->account_info
,
8542 else if (hash_mode
== 13200)
8544 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8558 else if (hash_mode
== 13300)
8560 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8561 SIGNATURE_AXCRYPT_SHA1
,
8567 else if (hash_mode
== 13400)
8569 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8571 keepass_t
*keepass
= &keepasss
[salt_pos
];
8573 u32 version
= (u32
) keepass
->version
;
8574 u32 rounds
= salt
.salt_iter
;
8575 u32 algorithm
= (u32
) keepass
->algorithm
;
8576 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8578 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8579 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8580 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8581 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8582 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8584 /* specific to version 1 */
8588 /* specific to version 2 */
8589 u32 expected_bytes_len
;
8590 u32
*ptr_expected_bytes
;
8592 u32 final_random_seed_len
;
8593 u32 transf_random_seed_len
;
8595 u32 contents_hash_len
;
8597 transf_random_seed_len
= 8;
8599 contents_hash_len
= 8;
8600 final_random_seed_len
= 8;
8603 final_random_seed_len
= 4;
8605 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8611 char *ptr_data
= out_buf
;
8613 ptr_data
+= strlen(out_buf
);
8618 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8619 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8624 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8625 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8630 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8631 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8638 contents_len
= (u32
) keepass
->contents_len
;
8639 ptr_contents
= (u32
*) keepass
->contents
;
8641 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8642 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8654 char ptr_contents_len
[10] = { 0 };
8656 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8658 sprintf (ptr_data
, "%d", contents_len
);
8660 ptr_data
+= strlen(ptr_contents_len
);
8665 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8666 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8668 else if (version
== 2)
8670 expected_bytes_len
= 8;
8671 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8673 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8674 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8679 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8680 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8694 sprintf (ptr_data
, "%d", keyfile_len
);
8701 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8702 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8705 else if (hash_mode
== 13500)
8707 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8709 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8711 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8713 char pstoken_tmp
[1024 + 1] = { 0 };
8715 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8717 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8719 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8722 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8730 else if (hash_mode
== 13600)
8732 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8734 zip2_t
*zip2
= &zip2s
[salt_pos
];
8736 const u32 salt_len
= zip2
->salt_len
;
8738 char salt_tmp
[32 + 1] = { 0 };
8740 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8742 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8744 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8747 const u32 data_len
= zip2
->data_len
;
8749 char data_tmp
[8192 + 1] = { 0 };
8751 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8753 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8755 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8758 const u32 auth_len
= zip2
->auth_len
;
8760 char auth_tmp
[20 + 1] = { 0 };
8762 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8764 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8766 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8769 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8770 SIGNATURE_ZIP2_START
,
8776 zip2
->compress_length
,
8779 SIGNATURE_ZIP2_STOP
);
8781 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8783 snprintf (out_buf
, len
-1, "%s", hashfile
);
8785 else if (hash_mode
== 13800)
8787 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8789 win8phone_t
*esalt
= &esalts
[salt_pos
];
8791 char buf
[256 + 1] = { 0 };
8793 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8795 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8798 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8811 if (hash_type
== HASH_TYPE_MD4
)
8813 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8819 else if (hash_type
== HASH_TYPE_MD5
)
8821 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8827 else if (hash_type
== HASH_TYPE_SHA1
)
8829 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8836 else if (hash_type
== HASH_TYPE_SHA256
)
8838 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8848 else if (hash_type
== HASH_TYPE_SHA384
)
8850 uint
*ptr
= digest_buf
;
8852 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8860 else if (hash_type
== HASH_TYPE_SHA512
)
8862 uint
*ptr
= digest_buf
;
8864 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8874 else if (hash_type
== HASH_TYPE_LM
)
8876 snprintf (out_buf
, len
-1, "%08x%08x",
8880 else if (hash_type
== HASH_TYPE_ORACLEH
)
8882 snprintf (out_buf
, len
-1, "%08X%08X",
8886 else if (hash_type
== HASH_TYPE_BCRYPT
)
8888 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8889 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8891 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8893 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8895 else if (hash_type
== HASH_TYPE_KECCAK
)
8897 uint
*ptr
= digest_buf
;
8899 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8927 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8929 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8931 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8938 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8940 digest_buf
[ 0] = digest_buf
[ 0];
8941 digest_buf
[ 1] = digest_buf
[ 1];
8942 digest_buf
[ 2] = digest_buf
[ 2];
8943 digest_buf
[ 3] = digest_buf
[ 3];
8944 digest_buf
[ 4] = digest_buf
[ 4];
8945 digest_buf
[ 5] = digest_buf
[ 5];
8946 digest_buf
[ 6] = digest_buf
[ 6];
8947 digest_buf
[ 7] = digest_buf
[ 7];
8948 digest_buf
[ 8] = digest_buf
[ 8];
8949 digest_buf
[ 9] = digest_buf
[ 9];
8950 digest_buf
[10] = digest_buf
[10];
8951 digest_buf
[11] = digest_buf
[11];
8952 digest_buf
[12] = digest_buf
[12];
8953 digest_buf
[13] = digest_buf
[13];
8954 digest_buf
[14] = digest_buf
[14];
8955 digest_buf
[15] = digest_buf
[15];
8957 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8975 else if (hash_type
== HASH_TYPE_GOST
)
8977 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8987 else if (hash_type
== HASH_TYPE_MYSQL
)
8989 snprintf (out_buf
, len
-1, "%08x%08x",
8993 else if (hash_type
== HASH_TYPE_LOTUS5
)
8995 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9001 else if (hash_type
== HASH_TYPE_LOTUS6
)
9003 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9004 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9005 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9006 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9008 char buf
[16] = { 0 };
9010 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9011 memcpy (buf
+ 5, digest_buf
, 9);
9015 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9017 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9020 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9022 else if (hash_type
== HASH_TYPE_LOTUS8
)
9024 char buf
[52] = { 0 };
9028 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9034 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9038 buf
[26] = salt
.salt_buf_pc
[0];
9039 buf
[27] = salt
.salt_buf_pc
[1];
9043 memcpy (buf
+ 28, digest_buf
, 8);
9045 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9049 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9051 else if (hash_type
== HASH_TYPE_CRC32
)
9053 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9057 if (salt_type
== SALT_TYPE_INTERN
)
9059 size_t pos
= strlen (out_buf
);
9061 out_buf
[pos
] = data
.separator
;
9063 char *ptr
= (char *) salt
.salt_buf
;
9065 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9067 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9071 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9073 memset (hccap
, 0, sizeof (hccap_t
));
9075 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9077 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9079 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9080 wpa_t
*wpa
= &wpas
[salt_pos
];
9082 hccap
->keyver
= wpa
->keyver
;
9084 hccap
->eapol_size
= wpa
->eapol_size
;
9086 if (wpa
->keyver
!= 1)
9088 uint eapol_tmp
[64] = { 0 };
9090 for (uint i
= 0; i
< 64; i
++)
9092 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9095 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9099 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9102 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9103 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9104 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9105 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9107 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9109 uint dgst_size
= data
.dgst_size
;
9111 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9113 if (wpa
->keyver
!= 1)
9115 uint digest_tmp
[4] = { 0 };
9117 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9118 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9119 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9120 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9122 memcpy (hccap
->keymic
, digest_tmp
, 16);
9126 memcpy (hccap
->keymic
, digest_ptr
, 16);
9130 void SuspendThreads ()
9132 if (data
.devices_status
== STATUS_RUNNING
)
9134 hc_timer_set (&data
.timer_paused
);
9136 data
.devices_status
= STATUS_PAUSED
;
9138 log_info ("Paused");
9142 void ResumeThreads ()
9144 if (data
.devices_status
== STATUS_PAUSED
)
9148 hc_timer_get (data
.timer_paused
, ms_paused
);
9150 data
.ms_paused
+= ms_paused
;
9152 data
.devices_status
= STATUS_RUNNING
;
9154 log_info ("Resumed");
9160 if (data
.devices_status
!= STATUS_RUNNING
) return;
9162 data
.devices_status
= STATUS_BYPASS
;
9164 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9167 void stop_at_checkpoint ()
9169 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9171 if (data
.devices_status
!= STATUS_RUNNING
) return;
9174 // this feature only makes sense if --restore-disable was not specified
9176 if (data
.restore_disable
== 1)
9178 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9183 // check if monitoring of Restore Point updates should be enabled or disabled
9185 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9187 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9189 // save the current restore point value
9191 data
.checkpoint_cur_words
= get_lowest_words_done ();
9193 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9197 data
.devices_status
= STATUS_RUNNING
;
9199 // reset the global value for checkpoint checks
9201 data
.checkpoint_cur_words
= 0;
9203 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9209 if (data
.devices_status
== STATUS_INIT
) return;
9210 if (data
.devices_status
== STATUS_STARTING
) return;
9212 data
.devices_status
= STATUS_ABORTED
;
9217 if (data
.devices_status
== STATUS_INIT
) return;
9218 if (data
.devices_status
== STATUS_STARTING
) return;
9220 data
.devices_status
= STATUS_QUIT
;
9223 void naive_escape (const char *cpath_real
, char *cpath_escaped
, const size_t cpath_escaped_len
)
9225 const size_t len
= strlen (cpath_real
);
9227 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9229 const u8 c
= cpath_real
[in
];
9233 cpath_escaped
[out
] = '\\';
9238 if (out
== cpath_escaped_len
) break;
9240 cpath_escaped
[out
] = c
;
9244 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9246 FILE *fp
= fopen (kernel_file
, "rb");
9252 memset (&st
, 0, sizeof (st
));
9254 stat (kernel_file
, &st
);
9256 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9258 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9260 if (num_read
!= (size_t) st
.st_size
)
9262 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9269 buf
[st
.st_size
] = 0;
9271 for (int i
= 0; i
< num_devices
; i
++)
9273 kernel_lengths
[i
] = (size_t) st
.st_size
;
9275 kernel_sources
[i
] = buf
;
9280 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9288 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9290 if (binary_size
> 0)
9292 FILE *fp
= fopen (dst
, "wb");
9295 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9306 restore_data_t
*init_restore (int argc
, char **argv
)
9308 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9310 if (data
.restore_disable
== 0)
9312 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9316 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9320 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9329 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9331 int pidbin_len
= -1;
9334 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9336 FILE *fd
= fopen (pidbin
, "rb");
9340 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9342 pidbin
[pidbin_len
] = 0;
9346 char *argv0_r
= strrchr (argv
[0], '/');
9348 char *pidbin_r
= strrchr (pidbin
, '/');
9350 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9352 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9354 if (strcmp (argv0_r
, pidbin_r
) == 0)
9356 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9363 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9365 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9367 int pidbin2_len
= -1;
9369 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9370 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9372 pidbin
[pidbin_len
] = 0;
9373 pidbin2
[pidbin2_len
] = 0;
9377 if (strcmp (pidbin
, pidbin2
) == 0)
9379 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9392 if (rd
->version_bin
< RESTORE_MIN
)
9394 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9401 memset (rd
, 0, sizeof (restore_data_t
));
9403 rd
->version_bin
= VERSION_BIN
;
9406 rd
->pid
= getpid ();
9408 rd
->pid
= GetCurrentProcessId ();
9411 if (getcwd (rd
->cwd
, 255) == NULL
)
9424 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9426 FILE *fp
= fopen (eff_restore_file
, "rb");
9430 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9435 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9437 log_error ("ERROR: Can't read %s", eff_restore_file
);
9442 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9444 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9446 for (uint i
= 0; i
< rd
->argc
; i
++)
9448 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9450 log_error ("ERROR: Can't read %s", eff_restore_file
);
9455 size_t len
= strlen (buf
);
9457 if (len
) buf
[len
- 1] = 0;
9459 rd
->argv
[i
] = mystrdup (buf
);
9466 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9468 if (chdir (rd
->cwd
))
9470 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9471 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9472 " https://github.com/philsmd/analyze_hc_restore\n"
9473 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9479 u64
get_lowest_words_done ()
9483 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9485 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9487 if (device_param
->skipped
) continue;
9489 const u64 words_done
= device_param
->words_done
;
9491 if (words_done
< words_cur
) words_cur
= words_done
;
9494 // It's possible that a device's workload isn't finished right after a restore-case.
9495 // In that case, this function would return 0 and overwrite the real restore point
9496 // There's also data.words_cur which is set to rd->words_cur but it changes while
9497 // the attack is running therefore we should stick to rd->words_cur.
9498 // Note that -s influences rd->words_cur we should keep a close look on that.
9500 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9505 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9507 u64 words_cur
= get_lowest_words_done ();
9509 rd
->words_cur
= words_cur
;
9511 FILE *fp
= fopen (new_restore_file
, "wb");
9515 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9520 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9522 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9527 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9529 for (uint i
= 0; i
< rd
->argc
; i
++)
9531 fprintf (fp
, "%s", rd
->argv
[i
]);
9537 fsync (fileno (fp
));
9542 void cycle_restore ()
9544 const char *eff_restore_file
= data
.eff_restore_file
;
9545 const char *new_restore_file
= data
.new_restore_file
;
9547 restore_data_t
*rd
= data
.rd
;
9549 write_restore (new_restore_file
, rd
);
9553 memset (&st
, 0, sizeof(st
));
9555 if (stat (eff_restore_file
, &st
) == 0)
9557 if (unlink (eff_restore_file
))
9559 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9563 if (rename (new_restore_file
, eff_restore_file
))
9565 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9569 void check_checkpoint ()
9571 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9573 u64 words_cur
= get_lowest_words_done ();
9575 if (words_cur
!= data
.checkpoint_cur_words
)
9585 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9589 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9591 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9593 myfree (alias
->device_name
);
9594 myfree (alias
->alias_name
);
9597 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9599 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9601 myfree (entry
->device_name
);
9604 myfree (tuning_db
->alias_buf
);
9605 myfree (tuning_db
->entry_buf
);
9610 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9612 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9614 int num_lines
= count_lines (fp
);
9616 // a bit over-allocated
9618 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9619 tuning_db
->alias_cnt
= 0;
9621 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9622 tuning_db
->entry_cnt
= 0;
9627 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9629 FILE *fp
= fopen (tuning_db_file
, "rb");
9633 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9638 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9644 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9648 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9650 if (line_buf
== NULL
) break;
9654 const int line_len
= in_superchop (line_buf
);
9656 if (line_len
== 0) continue;
9658 if (line_buf
[0] == '#') continue;
9662 char *token_ptr
[7] = { NULL
};
9666 char *next
= strtok (line_buf
, "\t ");
9668 token_ptr
[token_cnt
] = next
;
9672 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9674 token_ptr
[token_cnt
] = next
;
9681 char *device_name
= token_ptr
[0];
9682 char *alias_name
= token_ptr
[1];
9684 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9686 alias
->device_name
= mystrdup (device_name
);
9687 alias
->alias_name
= mystrdup (alias_name
);
9689 tuning_db
->alias_cnt
++;
9691 else if (token_cnt
== 6)
9693 if ((token_ptr
[1][0] != '0') &&
9694 (token_ptr
[1][0] != '1') &&
9695 (token_ptr
[1][0] != '3') &&
9696 (token_ptr
[1][0] != '*'))
9698 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9703 if ((token_ptr
[3][0] != '1') &&
9704 (token_ptr
[3][0] != '2') &&
9705 (token_ptr
[3][0] != '4') &&
9706 (token_ptr
[3][0] != '8') &&
9707 (token_ptr
[3][0] != 'N'))
9709 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9714 char *device_name
= token_ptr
[0];
9716 int attack_mode
= -1;
9718 int vector_width
= -1;
9719 int kernel_accel
= -1;
9720 int kernel_loops
= -1;
9722 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9723 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9724 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9726 if (token_ptr
[4][0] != 'A')
9728 kernel_accel
= atoi (token_ptr
[4]);
9730 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9732 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9742 if (token_ptr
[5][0] != 'A')
9744 kernel_loops
= atoi (token_ptr
[5]);
9746 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9748 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9758 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9760 entry
->device_name
= mystrdup (device_name
);
9761 entry
->attack_mode
= attack_mode
;
9762 entry
->hash_type
= hash_type
;
9763 entry
->vector_width
= vector_width
;
9764 entry
->kernel_accel
= kernel_accel
;
9765 entry
->kernel_loops
= kernel_loops
;
9767 tuning_db
->entry_cnt
++;
9771 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9781 // todo: print loaded 'cnt' message
9783 // sort the database
9785 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9786 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9791 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9793 static tuning_db_entry_t s
;
9795 // first we need to convert all spaces in the device_name to underscore
9797 char *device_name_nospace
= strdup (device_param
->device_name
);
9799 int device_name_length
= strlen (device_name_nospace
);
9803 for (i
= 0; i
< device_name_length
; i
++)
9805 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9808 // find out if there's an alias configured
9810 tuning_db_alias_t a
;
9812 a
.device_name
= device_name_nospace
;
9814 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
);
9816 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9818 // attack-mode 6 and 7 are attack-mode 1 basically
9820 if (attack_mode
== 6) attack_mode
= 1;
9821 if (attack_mode
== 7) attack_mode
= 1;
9823 // bsearch is not ideal but fast enough
9825 s
.device_name
= device_name_nospace
;
9826 s
.attack_mode
= attack_mode
;
9827 s
.hash_type
= hash_type
;
9829 tuning_db_entry_t
*entry
= NULL
;
9831 // this will produce all 2^3 combinations required
9833 for (i
= 0; i
< 8; i
++)
9835 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9836 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9837 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9839 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9841 if (entry
!= NULL
) break;
9843 // in non-wildcard mode do some additional checks:
9847 // in case we have an alias-name
9849 if (alias_name
!= NULL
)
9851 s
.device_name
= alias_name
;
9853 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9855 if (entry
!= NULL
) break;
9858 // or by device type
9860 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9862 s
.device_name
= "DEVICE_TYPE_CPU";
9864 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9866 s
.device_name
= "DEVICE_TYPE_GPU";
9868 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9870 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9873 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9875 if (entry
!= NULL
) break;
9879 // free converted device_name
9881 myfree (device_name_nospace
);
9890 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9892 u8 tmp
[256] = { 0 };
9894 if (salt_len
> sizeof (tmp
))
9899 memcpy (tmp
, in
, salt_len
);
9901 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9903 if ((salt_len
% 2) == 0)
9905 u32 new_salt_len
= salt_len
/ 2;
9907 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9912 tmp
[i
] = hex_convert (p1
) << 0;
9913 tmp
[i
] |= hex_convert (p0
) << 4;
9916 salt_len
= new_salt_len
;
9923 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9925 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9928 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9930 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9934 u32
*tmp_uint
= (u32
*) tmp
;
9936 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9937 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9938 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9939 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9940 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9941 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9942 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9943 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9944 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9945 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9947 salt_len
= salt_len
* 2;
9955 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9957 lowercase (tmp
, salt_len
);
9960 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9962 uppercase (tmp
, salt_len
);
9967 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9972 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9977 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9979 u32
*tmp_uint
= (uint
*) tmp
;
9985 for (u32 i
= 0; i
< max
; i
++)
9987 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9990 // Important: we may need to increase the length of memcpy since
9991 // we don't want to "loose" some swapped bytes (could happen if
9992 // they do not perfectly fit in the 4-byte blocks)
9993 // Memcpy does always copy the bytes in the BE order, but since
9994 // we swapped them, some important bytes could be in positions
9995 // we normally skip with the original len
9997 if (len
% 4) len
+= 4 - (len
% 4);
10000 memcpy (out
, tmp
, len
);
10005 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10007 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10009 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10011 u32
*digest
= (u32
*) hash_buf
->digest
;
10013 salt_t
*salt
= hash_buf
->salt
;
10015 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10017 char *iter_pos
= input_buf
+ 4;
10019 salt
->salt_iter
= 1 << atoi (iter_pos
);
10021 char *salt_pos
= strchr (iter_pos
, '$');
10023 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10027 uint salt_len
= 16;
10029 salt
->salt_len
= salt_len
;
10031 u8 tmp_buf
[100] = { 0 };
10033 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10037 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10039 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10040 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10041 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10042 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10044 char *hash_pos
= salt_pos
+ 22;
10046 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10048 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10050 memcpy (digest
, tmp_buf
, 24);
10052 digest
[0] = byte_swap_32 (digest
[0]);
10053 digest
[1] = byte_swap_32 (digest
[1]);
10054 digest
[2] = byte_swap_32 (digest
[2]);
10055 digest
[3] = byte_swap_32 (digest
[3]);
10056 digest
[4] = byte_swap_32 (digest
[4]);
10057 digest
[5] = byte_swap_32 (digest
[5]);
10059 digest
[5] &= ~0xff; // its just 23 not 24 !
10061 return (PARSER_OK
);
10064 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10066 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10068 u32
*digest
= (u32
*) hash_buf
->digest
;
10070 u8 tmp_buf
[100] = { 0 };
10072 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10074 memcpy (digest
, tmp_buf
, 32);
10076 digest
[0] = byte_swap_32 (digest
[0]);
10077 digest
[1] = byte_swap_32 (digest
[1]);
10078 digest
[2] = byte_swap_32 (digest
[2]);
10079 digest
[3] = byte_swap_32 (digest
[3]);
10080 digest
[4] = byte_swap_32 (digest
[4]);
10081 digest
[5] = byte_swap_32 (digest
[5]);
10082 digest
[6] = byte_swap_32 (digest
[6]);
10083 digest
[7] = byte_swap_32 (digest
[7]);
10085 digest
[0] -= SHA256M_A
;
10086 digest
[1] -= SHA256M_B
;
10087 digest
[2] -= SHA256M_C
;
10088 digest
[3] -= SHA256M_D
;
10089 digest
[4] -= SHA256M_E
;
10090 digest
[5] -= SHA256M_F
;
10091 digest
[6] -= SHA256M_G
;
10092 digest
[7] -= SHA256M_H
;
10094 return (PARSER_OK
);
10097 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10099 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10101 u32
*digest
= (u32
*) hash_buf
->digest
;
10103 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10104 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10106 digest
[0] = byte_swap_32 (digest
[0]);
10107 digest
[1] = byte_swap_32 (digest
[1]);
10111 IP (digest
[0], digest
[1], tt
);
10113 digest
[0] = digest
[0];
10114 digest
[1] = digest
[1];
10118 return (PARSER_OK
);
10121 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10123 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10125 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10127 u32
*digest
= (u32
*) hash_buf
->digest
;
10129 salt_t
*salt
= hash_buf
->salt
;
10131 char *hash_pos
= input_buf
+ 10;
10133 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10134 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10135 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10136 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10137 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10139 digest
[0] -= SHA1M_A
;
10140 digest
[1] -= SHA1M_B
;
10141 digest
[2] -= SHA1M_C
;
10142 digest
[3] -= SHA1M_D
;
10143 digest
[4] -= SHA1M_E
;
10145 uint salt_len
= 10;
10147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10149 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10151 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10153 salt
->salt_len
= salt_len
;
10155 return (PARSER_OK
);
10158 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10160 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10162 u32
*digest
= (u32
*) hash_buf
->digest
;
10164 salt_t
*salt
= hash_buf
->salt
;
10166 char *hash_pos
= input_buf
+ 8;
10168 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10169 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10170 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10171 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10172 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10174 digest
[0] -= SHA1M_A
;
10175 digest
[1] -= SHA1M_B
;
10176 digest
[2] -= SHA1M_C
;
10177 digest
[3] -= SHA1M_D
;
10178 digest
[4] -= SHA1M_E
;
10182 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10184 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10186 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10188 salt
->salt_len
= salt_len
;
10190 return (PARSER_OK
);
10193 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10195 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10197 u64
*digest
= (u64
*) hash_buf
->digest
;
10199 salt_t
*salt
= hash_buf
->salt
;
10201 char *hash_pos
= input_buf
+ 8;
10203 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10204 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10205 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10206 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10207 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10208 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10209 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10210 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10212 digest
[0] -= SHA512M_A
;
10213 digest
[1] -= SHA512M_B
;
10214 digest
[2] -= SHA512M_C
;
10215 digest
[3] -= SHA512M_D
;
10216 digest
[4] -= SHA512M_E
;
10217 digest
[5] -= SHA512M_F
;
10218 digest
[6] -= SHA512M_G
;
10219 digest
[7] -= SHA512M_H
;
10223 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10225 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10227 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10229 salt
->salt_len
= salt_len
;
10231 return (PARSER_OK
);
10234 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10236 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10238 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10242 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10245 u32
*digest
= (u32
*) hash_buf
->digest
;
10247 salt_t
*salt
= hash_buf
->salt
;
10249 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10250 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10251 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10252 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10254 digest
[0] = byte_swap_32 (digest
[0]);
10255 digest
[1] = byte_swap_32 (digest
[1]);
10256 digest
[2] = byte_swap_32 (digest
[2]);
10257 digest
[3] = byte_swap_32 (digest
[3]);
10259 digest
[0] -= MD5M_A
;
10260 digest
[1] -= MD5M_B
;
10261 digest
[2] -= MD5M_C
;
10262 digest
[3] -= MD5M_D
;
10264 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10266 uint salt_len
= input_len
- 32 - 1;
10268 char *salt_buf
= input_buf
+ 32 + 1;
10270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10276 salt
->salt_len
= salt_len
;
10278 return (PARSER_OK
);
10281 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10283 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10285 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10289 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10294 char clean_input_buf
[32] = { 0 };
10296 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10297 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10299 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10303 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10309 clean_input_buf
[k
] = input_buf
[i
];
10317 u32
*digest
= (u32
*) hash_buf
->digest
;
10319 salt_t
*salt
= hash_buf
->salt
;
10321 u32 a
, b
, c
, d
, e
, f
;
10323 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10324 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10325 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10326 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10327 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10328 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10330 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10331 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10333 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10334 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10335 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10336 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10337 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10338 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10340 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10341 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10343 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10344 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10345 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10346 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10347 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10348 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10350 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10351 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10353 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10354 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10355 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10356 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10357 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10358 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10360 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10361 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10363 digest
[0] = byte_swap_32 (digest
[0]);
10364 digest
[1] = byte_swap_32 (digest
[1]);
10365 digest
[2] = byte_swap_32 (digest
[2]);
10366 digest
[3] = byte_swap_32 (digest
[3]);
10368 digest
[0] -= MD5M_A
;
10369 digest
[1] -= MD5M_B
;
10370 digest
[2] -= MD5M_C
;
10371 digest
[3] -= MD5M_D
;
10373 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10375 uint salt_len
= input_len
- 30 - 1;
10377 char *salt_buf
= input_buf
+ 30 + 1;
10379 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10381 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10383 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10384 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10386 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10388 salt
->salt_len
= salt_len
;
10390 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10392 salt
->salt_len
+= 22;
10394 return (PARSER_OK
);
10397 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10399 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10401 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10405 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10408 u32
*digest
= (u32
*) hash_buf
->digest
;
10410 salt_t
*salt
= hash_buf
->salt
;
10412 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10413 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10414 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10415 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10416 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10418 digest
[0] -= SHA1M_A
;
10419 digest
[1] -= SHA1M_B
;
10420 digest
[2] -= SHA1M_C
;
10421 digest
[3] -= SHA1M_D
;
10422 digest
[4] -= SHA1M_E
;
10424 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10426 uint salt_len
= input_len
- 40 - 1;
10428 char *salt_buf
= input_buf
+ 40 + 1;
10430 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10432 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10434 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10436 salt
->salt_len
= salt_len
;
10438 return (PARSER_OK
);
10441 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10443 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10445 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10449 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10452 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10454 char *iter_pos
= input_buf
+ 6;
10456 salt_t
*salt
= hash_buf
->salt
;
10458 uint iter
= atoi (iter_pos
);
10462 iter
= ROUNDS_DCC2
;
10465 salt
->salt_iter
= iter
- 1;
10467 char *salt_pos
= strchr (iter_pos
, '#');
10469 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10473 char *digest_pos
= strchr (salt_pos
, '#');
10475 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10479 uint salt_len
= digest_pos
- salt_pos
- 1;
10481 u32
*digest
= (u32
*) hash_buf
->digest
;
10483 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10484 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10485 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10486 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10488 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10490 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10492 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10494 salt
->salt_len
= salt_len
;
10496 return (PARSER_OK
);
10499 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10501 u32
*digest
= (u32
*) hash_buf
->digest
;
10503 salt_t
*salt
= hash_buf
->salt
;
10505 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10509 memcpy (&in
, input_buf
, input_len
);
10511 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10513 memcpy (digest
, in
.keymic
, 16);
10516 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10517 The phrase "Pairwise key expansion"
10518 Access Point Address (referred to as Authenticator Address AA)
10519 Supplicant Address (referred to as Supplicant Address SA)
10520 Access Point Nonce (referred to as Authenticator Anonce)
10521 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10524 uint salt_len
= strlen (in
.essid
);
10528 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10530 return (PARSER_SALT_LENGTH
);
10533 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10535 salt
->salt_len
= salt_len
;
10537 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10539 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10541 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10543 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10545 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10546 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10550 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10551 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10554 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10556 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10557 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10561 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10562 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10565 for (int i
= 0; i
< 25; i
++)
10567 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10570 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10571 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10572 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10573 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10575 wpa
->keyver
= in
.keyver
;
10577 if (wpa
->keyver
> 255)
10579 log_info ("ATTENTION!");
10580 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10581 log_info (" This could be due to a recent aircrack-ng bug.");
10582 log_info (" The key version was automatically reset to a reasonable value.");
10585 wpa
->keyver
&= 0xff;
10588 wpa
->eapol_size
= in
.eapol_size
;
10590 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10592 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10594 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10596 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10598 if (wpa
->keyver
== 1)
10604 digest
[0] = byte_swap_32 (digest
[0]);
10605 digest
[1] = byte_swap_32 (digest
[1]);
10606 digest
[2] = byte_swap_32 (digest
[2]);
10607 digest
[3] = byte_swap_32 (digest
[3]);
10609 for (int i
= 0; i
< 64; i
++)
10611 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10615 uint32_t *p0
= (uint32_t *) in
.essid
;
10619 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10620 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10622 salt
->salt_buf
[10] = c0
;
10623 salt
->salt_buf
[11] = c1
;
10625 return (PARSER_OK
);
10628 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10630 u32
*digest
= (u32
*) hash_buf
->digest
;
10632 salt_t
*salt
= hash_buf
->salt
;
10634 if (input_len
== 0)
10636 log_error ("Password Safe v2 container not specified");
10641 FILE *fp
= fopen (input_buf
, "rb");
10645 log_error ("%s: %s", input_buf
, strerror (errno
));
10652 memset (&buf
, 0, sizeof (psafe2_hdr
));
10654 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10658 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10660 salt
->salt_buf
[0] = buf
.random
[0];
10661 salt
->salt_buf
[1] = buf
.random
[1];
10663 salt
->salt_len
= 8;
10664 salt
->salt_iter
= 1000;
10666 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10667 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10668 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10669 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10670 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10672 return (PARSER_OK
);
10675 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10677 u32
*digest
= (u32
*) hash_buf
->digest
;
10679 salt_t
*salt
= hash_buf
->salt
;
10681 if (input_len
== 0)
10683 log_error (".psafe3 not specified");
10688 FILE *fp
= fopen (input_buf
, "rb");
10692 log_error ("%s: %s", input_buf
, strerror (errno
));
10699 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10703 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10705 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10707 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10709 salt
->salt_iter
= in
.iterations
+ 1;
10711 salt
->salt_buf
[0] = in
.salt_buf
[0];
10712 salt
->salt_buf
[1] = in
.salt_buf
[1];
10713 salt
->salt_buf
[2] = in
.salt_buf
[2];
10714 salt
->salt_buf
[3] = in
.salt_buf
[3];
10715 salt
->salt_buf
[4] = in
.salt_buf
[4];
10716 salt
->salt_buf
[5] = in
.salt_buf
[5];
10717 salt
->salt_buf
[6] = in
.salt_buf
[6];
10718 salt
->salt_buf
[7] = in
.salt_buf
[7];
10720 salt
->salt_len
= 32;
10722 digest
[0] = in
.hash_buf
[0];
10723 digest
[1] = in
.hash_buf
[1];
10724 digest
[2] = in
.hash_buf
[2];
10725 digest
[3] = in
.hash_buf
[3];
10726 digest
[4] = in
.hash_buf
[4];
10727 digest
[5] = in
.hash_buf
[5];
10728 digest
[6] = in
.hash_buf
[6];
10729 digest
[7] = in
.hash_buf
[7];
10731 digest
[0] = byte_swap_32 (digest
[0]);
10732 digest
[1] = byte_swap_32 (digest
[1]);
10733 digest
[2] = byte_swap_32 (digest
[2]);
10734 digest
[3] = byte_swap_32 (digest
[3]);
10735 digest
[4] = byte_swap_32 (digest
[4]);
10736 digest
[5] = byte_swap_32 (digest
[5]);
10737 digest
[6] = byte_swap_32 (digest
[6]);
10738 digest
[7] = byte_swap_32 (digest
[7]);
10740 return (PARSER_OK
);
10743 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10745 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10747 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10749 u32
*digest
= (u32
*) hash_buf
->digest
;
10751 salt_t
*salt
= hash_buf
->salt
;
10753 char *iter_pos
= input_buf
+ 3;
10755 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10757 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10759 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10761 salt
->salt_iter
= salt_iter
;
10763 char *salt_pos
= iter_pos
+ 1;
10767 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10769 salt
->salt_len
= salt_len
;
10771 char *hash_pos
= salt_pos
+ salt_len
;
10773 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10775 return (PARSER_OK
);
10778 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10780 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10782 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10784 u32
*digest
= (u32
*) hash_buf
->digest
;
10786 salt_t
*salt
= hash_buf
->salt
;
10788 char *salt_pos
= input_buf
+ 3;
10790 uint iterations_len
= 0;
10792 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10796 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10798 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10799 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10803 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10807 iterations_len
+= 8;
10811 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10814 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10816 char *hash_pos
= strchr (salt_pos
, '$');
10818 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10820 uint salt_len
= hash_pos
- salt_pos
;
10822 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10824 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10826 salt
->salt_len
= salt_len
;
10830 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10832 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10834 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10836 return (PARSER_OK
);
10839 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10841 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10843 u32
*digest
= (u32
*) hash_buf
->digest
;
10845 salt_t
*salt
= hash_buf
->salt
;
10847 char *salt_pos
= input_buf
+ 6;
10849 uint iterations_len
= 0;
10851 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10855 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10857 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10858 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10862 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10866 iterations_len
+= 8;
10870 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10873 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10875 char *hash_pos
= strchr (salt_pos
, '$');
10877 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10879 uint salt_len
= hash_pos
- salt_pos
;
10881 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10883 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10885 salt
->salt_len
= salt_len
;
10889 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10891 return (PARSER_OK
);
10894 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10896 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10898 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10900 u32
*digest
= (u32
*) hash_buf
->digest
;
10902 salt_t
*salt
= hash_buf
->salt
;
10904 char *salt_pos
= input_buf
+ 14;
10906 char *hash_pos
= strchr (salt_pos
, '*');
10908 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10912 uint salt_len
= hash_pos
- salt_pos
- 1;
10914 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10916 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10918 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10920 salt
->salt_len
= salt_len
;
10922 u8 tmp_buf
[100] = { 0 };
10924 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10926 memcpy (digest
, tmp_buf
, 20);
10928 digest
[0] = byte_swap_32 (digest
[0]);
10929 digest
[1] = byte_swap_32 (digest
[1]);
10930 digest
[2] = byte_swap_32 (digest
[2]);
10931 digest
[3] = byte_swap_32 (digest
[3]);
10932 digest
[4] = byte_swap_32 (digest
[4]);
10934 digest
[0] -= SHA1M_A
;
10935 digest
[1] -= SHA1M_B
;
10936 digest
[2] -= SHA1M_C
;
10937 digest
[3] -= SHA1M_D
;
10938 digest
[4] -= SHA1M_E
;
10940 return (PARSER_OK
);
10943 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10945 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10947 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10949 if (c12
& 3) return (PARSER_HASH_VALUE
);
10951 u32
*digest
= (u32
*) hash_buf
->digest
;
10953 salt_t
*salt
= hash_buf
->salt
;
10955 // for ascii_digest
10956 salt
->salt_sign
[0] = input_buf
[0];
10957 salt
->salt_sign
[1] = input_buf
[1];
10959 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10960 | itoa64_to_int (input_buf
[1]) << 6;
10962 salt
->salt_len
= 2;
10964 u8 tmp_buf
[100] = { 0 };
10966 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10968 memcpy (digest
, tmp_buf
, 8);
10972 IP (digest
[0], digest
[1], tt
);
10977 return (PARSER_OK
);
10980 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10982 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10984 u32
*digest
= (u32
*) hash_buf
->digest
;
10986 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10987 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10988 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10989 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10991 digest
[0] = byte_swap_32 (digest
[0]);
10992 digest
[1] = byte_swap_32 (digest
[1]);
10993 digest
[2] = byte_swap_32 (digest
[2]);
10994 digest
[3] = byte_swap_32 (digest
[3]);
10996 digest
[0] -= MD4M_A
;
10997 digest
[1] -= MD4M_B
;
10998 digest
[2] -= MD4M_C
;
10999 digest
[3] -= MD4M_D
;
11001 return (PARSER_OK
);
11004 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11006 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11008 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11012 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11015 u32
*digest
= (u32
*) hash_buf
->digest
;
11017 salt_t
*salt
= hash_buf
->salt
;
11019 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11020 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11021 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11022 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11024 digest
[0] = byte_swap_32 (digest
[0]);
11025 digest
[1] = byte_swap_32 (digest
[1]);
11026 digest
[2] = byte_swap_32 (digest
[2]);
11027 digest
[3] = byte_swap_32 (digest
[3]);
11029 digest
[0] -= MD4M_A
;
11030 digest
[1] -= MD4M_B
;
11031 digest
[2] -= MD4M_C
;
11032 digest
[3] -= MD4M_D
;
11034 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11036 uint salt_len
= input_len
- 32 - 1;
11038 char *salt_buf
= input_buf
+ 32 + 1;
11040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11042 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11044 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11046 salt
->salt_len
= salt_len
;
11048 return (PARSER_OK
);
11051 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11053 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11055 u32
*digest
= (u32
*) hash_buf
->digest
;
11057 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11058 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11059 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11060 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11062 digest
[0] = byte_swap_32 (digest
[0]);
11063 digest
[1] = byte_swap_32 (digest
[1]);
11064 digest
[2] = byte_swap_32 (digest
[2]);
11065 digest
[3] = byte_swap_32 (digest
[3]);
11067 digest
[0] -= MD5M_A
;
11068 digest
[1] -= MD5M_B
;
11069 digest
[2] -= MD5M_C
;
11070 digest
[3] -= MD5M_D
;
11072 return (PARSER_OK
);
11075 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11077 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11079 u32
*digest
= (u32
*) hash_buf
->digest
;
11081 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11082 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11086 digest
[0] = byte_swap_32 (digest
[0]);
11087 digest
[1] = byte_swap_32 (digest
[1]);
11089 return (PARSER_OK
);
11092 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11094 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11096 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11100 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11103 u32
*digest
= (u32
*) hash_buf
->digest
;
11105 salt_t
*salt
= hash_buf
->salt
;
11107 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11108 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11109 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11110 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11112 digest
[0] = byte_swap_32 (digest
[0]);
11113 digest
[1] = byte_swap_32 (digest
[1]);
11114 digest
[2] = byte_swap_32 (digest
[2]);
11115 digest
[3] = byte_swap_32 (digest
[3]);
11117 digest
[0] -= MD5M_A
;
11118 digest
[1] -= MD5M_B
;
11119 digest
[2] -= MD5M_C
;
11120 digest
[3] -= MD5M_D
;
11122 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11124 uint salt_len
= input_len
- 32 - 1;
11126 char *salt_buf
= input_buf
+ 32 + 1;
11128 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11130 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11132 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11134 salt
->salt_len
= salt_len
;
11136 return (PARSER_OK
);
11139 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11141 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11143 u32
*digest
= (u32
*) hash_buf
->digest
;
11145 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11146 | itoa64_to_int (input_buf
[ 1]) << 6
11147 | itoa64_to_int (input_buf
[ 2]) << 12
11148 | itoa64_to_int (input_buf
[ 3]) << 18;
11149 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11150 | itoa64_to_int (input_buf
[ 5]) << 6
11151 | itoa64_to_int (input_buf
[ 6]) << 12
11152 | itoa64_to_int (input_buf
[ 7]) << 18;
11153 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11154 | itoa64_to_int (input_buf
[ 9]) << 6
11155 | itoa64_to_int (input_buf
[10]) << 12
11156 | itoa64_to_int (input_buf
[11]) << 18;
11157 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11158 | itoa64_to_int (input_buf
[13]) << 6
11159 | itoa64_to_int (input_buf
[14]) << 12
11160 | itoa64_to_int (input_buf
[15]) << 18;
11162 digest
[0] -= MD5M_A
;
11163 digest
[1] -= MD5M_B
;
11164 digest
[2] -= MD5M_C
;
11165 digest
[3] -= MD5M_D
;
11167 digest
[0] &= 0x00ffffff;
11168 digest
[1] &= 0x00ffffff;
11169 digest
[2] &= 0x00ffffff;
11170 digest
[3] &= 0x00ffffff;
11172 return (PARSER_OK
);
11175 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11177 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11179 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11183 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11186 u32
*digest
= (u32
*) hash_buf
->digest
;
11188 salt_t
*salt
= hash_buf
->salt
;
11190 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11191 | itoa64_to_int (input_buf
[ 1]) << 6
11192 | itoa64_to_int (input_buf
[ 2]) << 12
11193 | itoa64_to_int (input_buf
[ 3]) << 18;
11194 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11195 | itoa64_to_int (input_buf
[ 5]) << 6
11196 | itoa64_to_int (input_buf
[ 6]) << 12
11197 | itoa64_to_int (input_buf
[ 7]) << 18;
11198 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11199 | itoa64_to_int (input_buf
[ 9]) << 6
11200 | itoa64_to_int (input_buf
[10]) << 12
11201 | itoa64_to_int (input_buf
[11]) << 18;
11202 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11203 | itoa64_to_int (input_buf
[13]) << 6
11204 | itoa64_to_int (input_buf
[14]) << 12
11205 | itoa64_to_int (input_buf
[15]) << 18;
11207 digest
[0] -= MD5M_A
;
11208 digest
[1] -= MD5M_B
;
11209 digest
[2] -= MD5M_C
;
11210 digest
[3] -= MD5M_D
;
11212 digest
[0] &= 0x00ffffff;
11213 digest
[1] &= 0x00ffffff;
11214 digest
[2] &= 0x00ffffff;
11215 digest
[3] &= 0x00ffffff;
11217 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11219 uint salt_len
= input_len
- 16 - 1;
11221 char *salt_buf
= input_buf
+ 16 + 1;
11223 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11225 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11227 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11229 salt
->salt_len
= salt_len
;
11231 return (PARSER_OK
);
11234 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11236 key
[0] = (nthash
[0] >> 0);
11237 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11238 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11239 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11240 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11241 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11242 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11243 key
[7] = (nthash
[6] << 1);
11255 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11257 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11259 u32
*digest
= (u32
*) hash_buf
->digest
;
11261 salt_t
*salt
= hash_buf
->salt
;
11263 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11269 char *user_pos
= input_buf
;
11271 char *unused_pos
= strchr (user_pos
, ':');
11273 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11275 uint user_len
= unused_pos
- user_pos
;
11277 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11281 char *domain_pos
= strchr (unused_pos
, ':');
11283 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11285 uint unused_len
= domain_pos
- unused_pos
;
11287 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11291 char *srvchall_pos
= strchr (domain_pos
, ':');
11293 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11295 uint domain_len
= srvchall_pos
- domain_pos
;
11297 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11301 char *hash_pos
= strchr (srvchall_pos
, ':');
11303 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11305 uint srvchall_len
= hash_pos
- srvchall_pos
;
11307 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11311 char *clichall_pos
= strchr (hash_pos
, ':');
11313 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11315 uint hash_len
= clichall_pos
- hash_pos
;
11317 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11321 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11323 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11326 * store some data for later use
11329 netntlm
->user_len
= user_len
* 2;
11330 netntlm
->domain_len
= domain_len
* 2;
11331 netntlm
->srvchall_len
= srvchall_len
/ 2;
11332 netntlm
->clichall_len
= clichall_len
/ 2;
11334 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11335 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11338 * handle username and domainname
11341 for (uint i
= 0; i
< user_len
; i
++)
11343 *userdomain_ptr
++ = user_pos
[i
];
11344 *userdomain_ptr
++ = 0;
11347 for (uint i
= 0; i
< domain_len
; i
++)
11349 *userdomain_ptr
++ = domain_pos
[i
];
11350 *userdomain_ptr
++ = 0;
11354 * handle server challenge encoding
11357 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11359 const char p0
= srvchall_pos
[i
+ 0];
11360 const char p1
= srvchall_pos
[i
+ 1];
11362 *chall_ptr
++ = hex_convert (p1
) << 0
11363 | hex_convert (p0
) << 4;
11367 * handle client challenge encoding
11370 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11372 const char p0
= clichall_pos
[i
+ 0];
11373 const char p1
= clichall_pos
[i
+ 1];
11375 *chall_ptr
++ = hex_convert (p1
) << 0
11376 | hex_convert (p0
) << 4;
11383 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11385 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11387 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11389 salt
->salt_len
= salt_len
;
11391 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11392 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11393 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11394 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11396 digest
[0] = byte_swap_32 (digest
[0]);
11397 digest
[1] = byte_swap_32 (digest
[1]);
11398 digest
[2] = byte_swap_32 (digest
[2]);
11399 digest
[3] = byte_swap_32 (digest
[3]);
11401 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11403 uint digest_tmp
[2] = { 0 };
11405 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11406 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11408 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11409 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11411 /* special case 2: ESS */
11413 if (srvchall_len
== 48)
11415 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11417 uint w
[16] = { 0 };
11419 w
[ 0] = netntlm
->chall_buf
[6];
11420 w
[ 1] = netntlm
->chall_buf
[7];
11421 w
[ 2] = netntlm
->chall_buf
[0];
11422 w
[ 3] = netntlm
->chall_buf
[1];
11426 uint dgst
[4] = { 0 };
11435 salt
->salt_buf
[0] = dgst
[0];
11436 salt
->salt_buf
[1] = dgst
[1];
11440 /* precompute netntlmv1 exploit start */
11442 for (uint i
= 0; i
< 0x10000; i
++)
11444 uint key_md4
[2] = { i
, 0 };
11445 uint key_des
[2] = { 0, 0 };
11447 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11449 uint Kc
[16] = { 0 };
11450 uint Kd
[16] = { 0 };
11452 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11454 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11456 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11458 if (data3
[0] != digest_tmp
[0]) continue;
11459 if (data3
[1] != digest_tmp
[1]) continue;
11461 salt
->salt_buf
[2] = i
;
11463 salt
->salt_len
= 24;
11468 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11469 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11471 /* precompute netntlmv1 exploit stop */
11475 IP (digest
[0], digest
[1], tt
);
11476 IP (digest
[2], digest
[3], tt
);
11478 digest
[0] = rotr32 (digest
[0], 29);
11479 digest
[1] = rotr32 (digest
[1], 29);
11480 digest
[2] = rotr32 (digest
[2], 29);
11481 digest
[3] = rotr32 (digest
[3], 29);
11483 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11485 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11486 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11488 return (PARSER_OK
);
11491 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11493 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11495 u32
*digest
= (u32
*) hash_buf
->digest
;
11497 salt_t
*salt
= hash_buf
->salt
;
11499 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11505 char *user_pos
= input_buf
;
11507 char *unused_pos
= strchr (user_pos
, ':');
11509 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11511 uint user_len
= unused_pos
- user_pos
;
11513 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11517 char *domain_pos
= strchr (unused_pos
, ':');
11519 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11521 uint unused_len
= domain_pos
- unused_pos
;
11523 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11527 char *srvchall_pos
= strchr (domain_pos
, ':');
11529 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11531 uint domain_len
= srvchall_pos
- domain_pos
;
11533 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11537 char *hash_pos
= strchr (srvchall_pos
, ':');
11539 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11541 uint srvchall_len
= hash_pos
- srvchall_pos
;
11543 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11547 char *clichall_pos
= strchr (hash_pos
, ':');
11549 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11551 uint hash_len
= clichall_pos
- hash_pos
;
11553 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11557 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11559 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11561 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11564 * store some data for later use
11567 netntlm
->user_len
= user_len
* 2;
11568 netntlm
->domain_len
= domain_len
* 2;
11569 netntlm
->srvchall_len
= srvchall_len
/ 2;
11570 netntlm
->clichall_len
= clichall_len
/ 2;
11572 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11573 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11576 * handle username and domainname
11579 for (uint i
= 0; i
< user_len
; i
++)
11581 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11582 *userdomain_ptr
++ = 0;
11585 for (uint i
= 0; i
< domain_len
; i
++)
11587 *userdomain_ptr
++ = domain_pos
[i
];
11588 *userdomain_ptr
++ = 0;
11591 *userdomain_ptr
++ = 0x80;
11594 * handle server challenge encoding
11597 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11599 const char p0
= srvchall_pos
[i
+ 0];
11600 const char p1
= srvchall_pos
[i
+ 1];
11602 *chall_ptr
++ = hex_convert (p1
) << 0
11603 | hex_convert (p0
) << 4;
11607 * handle client challenge encoding
11610 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11612 const char p0
= clichall_pos
[i
+ 0];
11613 const char p1
= clichall_pos
[i
+ 1];
11615 *chall_ptr
++ = hex_convert (p1
) << 0
11616 | hex_convert (p0
) << 4;
11619 *chall_ptr
++ = 0x80;
11622 * handle hash itself
11625 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11626 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11627 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11628 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11630 digest
[0] = byte_swap_32 (digest
[0]);
11631 digest
[1] = byte_swap_32 (digest
[1]);
11632 digest
[2] = byte_swap_32 (digest
[2]);
11633 digest
[3] = byte_swap_32 (digest
[3]);
11636 * reuse challange data as salt_buf, its the buffer that is most likely unique
11639 salt
->salt_buf
[0] = 0;
11640 salt
->salt_buf
[1] = 0;
11641 salt
->salt_buf
[2] = 0;
11642 salt
->salt_buf
[3] = 0;
11643 salt
->salt_buf
[4] = 0;
11644 salt
->salt_buf
[5] = 0;
11645 salt
->salt_buf
[6] = 0;
11646 salt
->salt_buf
[7] = 0;
11650 uptr
= (uint
*) netntlm
->userdomain_buf
;
11652 for (uint i
= 0; i
< 16; i
+= 16)
11654 md5_64 (uptr
, salt
->salt_buf
);
11657 uptr
= (uint
*) netntlm
->chall_buf
;
11659 for (uint i
= 0; i
< 256; i
+= 16)
11661 md5_64 (uptr
, salt
->salt_buf
);
11664 salt
->salt_len
= 16;
11666 return (PARSER_OK
);
11669 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11671 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11673 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11677 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11680 u32
*digest
= (u32
*) hash_buf
->digest
;
11682 salt_t
*salt
= hash_buf
->salt
;
11684 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11685 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11686 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11687 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11689 digest
[0] = byte_swap_32 (digest
[0]);
11690 digest
[1] = byte_swap_32 (digest
[1]);
11691 digest
[2] = byte_swap_32 (digest
[2]);
11692 digest
[3] = byte_swap_32 (digest
[3]);
11694 digest
[0] -= MD5M_A
;
11695 digest
[1] -= MD5M_B
;
11696 digest
[2] -= MD5M_C
;
11697 digest
[3] -= MD5M_D
;
11699 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11701 uint salt_len
= input_len
- 32 - 1;
11703 char *salt_buf
= input_buf
+ 32 + 1;
11705 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11707 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11709 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11711 salt
->salt_len
= salt_len
;
11713 return (PARSER_OK
);
11716 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11718 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11720 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11724 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11727 u32
*digest
= (u32
*) hash_buf
->digest
;
11729 salt_t
*salt
= hash_buf
->salt
;
11731 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11732 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11733 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11734 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11736 digest
[0] = byte_swap_32 (digest
[0]);
11737 digest
[1] = byte_swap_32 (digest
[1]);
11738 digest
[2] = byte_swap_32 (digest
[2]);
11739 digest
[3] = byte_swap_32 (digest
[3]);
11741 digest
[0] -= MD5M_A
;
11742 digest
[1] -= MD5M_B
;
11743 digest
[2] -= MD5M_C
;
11744 digest
[3] -= MD5M_D
;
11746 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11748 uint salt_len
= input_len
- 32 - 1;
11750 char *salt_buf
= input_buf
+ 32 + 1;
11752 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11754 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11756 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11758 salt
->salt_len
= salt_len
;
11760 return (PARSER_OK
);
11763 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11765 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11767 u32
*digest
= (u32
*) hash_buf
->digest
;
11769 salt_t
*salt
= hash_buf
->salt
;
11771 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11772 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11773 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11774 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11776 digest
[0] = byte_swap_32 (digest
[0]);
11777 digest
[1] = byte_swap_32 (digest
[1]);
11778 digest
[2] = byte_swap_32 (digest
[2]);
11779 digest
[3] = byte_swap_32 (digest
[3]);
11781 digest
[0] -= MD5M_A
;
11782 digest
[1] -= MD5M_B
;
11783 digest
[2] -= MD5M_C
;
11784 digest
[3] -= MD5M_D
;
11787 * This is a virtual salt. While the algorithm is basically not salted
11788 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11789 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11792 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11794 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11796 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11798 salt
->salt_len
= salt_len
;
11800 return (PARSER_OK
);
11803 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11805 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11807 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11811 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11814 u32
*digest
= (u32
*) hash_buf
->digest
;
11816 salt_t
*salt
= hash_buf
->salt
;
11818 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11819 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11820 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11821 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11823 digest
[0] = byte_swap_32 (digest
[0]);
11824 digest
[1] = byte_swap_32 (digest
[1]);
11825 digest
[2] = byte_swap_32 (digest
[2]);
11826 digest
[3] = byte_swap_32 (digest
[3]);
11828 digest
[0] -= MD5M_A
;
11829 digest
[1] -= MD5M_B
;
11830 digest
[2] -= MD5M_C
;
11831 digest
[3] -= MD5M_D
;
11833 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11835 uint salt_len
= input_len
- 32 - 1;
11837 char *salt_buf
= input_buf
+ 32 + 1;
11839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11841 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11843 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11845 salt
->salt_len
= salt_len
;
11847 return (PARSER_OK
);
11850 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11852 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11854 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11858 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11861 u32
*digest
= (u32
*) hash_buf
->digest
;
11863 salt_t
*salt
= hash_buf
->salt
;
11865 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11866 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11867 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11868 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11870 digest
[0] = byte_swap_32 (digest
[0]);
11871 digest
[1] = byte_swap_32 (digest
[1]);
11872 digest
[2] = byte_swap_32 (digest
[2]);
11873 digest
[3] = byte_swap_32 (digest
[3]);
11875 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11877 uint salt_len
= input_len
- 32 - 1;
11879 char *salt_buf
= input_buf
+ 32 + 1;
11881 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11883 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11885 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11887 salt
->salt_len
= salt_len
;
11889 return (PARSER_OK
);
11892 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11894 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11896 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11900 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11903 u32
*digest
= (u32
*) hash_buf
->digest
;
11905 salt_t
*salt
= hash_buf
->salt
;
11907 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11908 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11909 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11910 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11912 digest
[0] = byte_swap_32 (digest
[0]);
11913 digest
[1] = byte_swap_32 (digest
[1]);
11914 digest
[2] = byte_swap_32 (digest
[2]);
11915 digest
[3] = byte_swap_32 (digest
[3]);
11917 digest
[0] -= MD4M_A
;
11918 digest
[1] -= MD4M_B
;
11919 digest
[2] -= MD4M_C
;
11920 digest
[3] -= MD4M_D
;
11922 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11924 uint salt_len
= input_len
- 32 - 1;
11926 char *salt_buf
= input_buf
+ 32 + 1;
11928 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11930 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11932 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11934 salt
->salt_len
= salt_len
;
11936 return (PARSER_OK
);
11939 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11941 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11943 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11947 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11950 u32
*digest
= (u32
*) hash_buf
->digest
;
11952 salt_t
*salt
= hash_buf
->salt
;
11954 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11955 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11956 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11957 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11959 digest
[0] = byte_swap_32 (digest
[0]);
11960 digest
[1] = byte_swap_32 (digest
[1]);
11961 digest
[2] = byte_swap_32 (digest
[2]);
11962 digest
[3] = byte_swap_32 (digest
[3]);
11964 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11966 uint salt_len
= input_len
- 32 - 1;
11968 char *salt_buf
= input_buf
+ 32 + 1;
11970 uint salt_pc_block
[16] = { 0 };
11972 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11974 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11978 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11980 salt_pc_block
[14] = salt_len
* 8;
11982 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11984 md5_64 (salt_pc_block
, salt_pc_digest
);
11986 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11987 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11988 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11989 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11991 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11993 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11995 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11997 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11998 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11999 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12000 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12002 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12004 return (PARSER_OK
);
12007 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12009 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12011 u32
*digest
= (u32
*) hash_buf
->digest
;
12013 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12014 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12015 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12016 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12017 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12019 digest
[0] -= SHA1M_A
;
12020 digest
[1] -= SHA1M_B
;
12021 digest
[2] -= SHA1M_C
;
12022 digest
[3] -= SHA1M_D
;
12023 digest
[4] -= SHA1M_E
;
12025 return (PARSER_OK
);
12028 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12030 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12032 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12034 u32
*digest
= (u32
*) hash_buf
->digest
;
12038 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12039 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12040 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12041 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12044 return (PARSER_OK
);
12047 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12049 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12051 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12055 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12058 u32
*digest
= (u32
*) hash_buf
->digest
;
12060 salt_t
*salt
= hash_buf
->salt
;
12062 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12063 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12064 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12065 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12066 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12068 digest
[0] -= SHA1M_A
;
12069 digest
[1] -= SHA1M_B
;
12070 digest
[2] -= SHA1M_C
;
12071 digest
[3] -= SHA1M_D
;
12072 digest
[4] -= SHA1M_E
;
12074 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12076 uint salt_len
= input_len
- 40 - 1;
12078 char *salt_buf
= input_buf
+ 40 + 1;
12080 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12082 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12084 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12086 salt
->salt_len
= salt_len
;
12088 return (PARSER_OK
);
12091 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12093 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12095 u32
*digest
= (u32
*) hash_buf
->digest
;
12097 salt_t
*salt
= hash_buf
->salt
;
12099 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12101 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12102 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12103 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12104 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12105 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12107 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12109 uint salt_len
= input_len
- 40 - 1;
12111 char *salt_buf
= input_buf
+ 40 + 1;
12113 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12115 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12117 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12119 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12122 pstoken
->salt_len
= salt_len
/ 2;
12124 /* some fake salt for the sorting mechanisms */
12126 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12127 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12128 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12129 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12130 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12131 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12132 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12133 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12135 salt
->salt_len
= 32;
12137 /* we need to check if we can precompute some of the data --
12138 this is possible since the scheme is badly designed */
12140 pstoken
->pc_digest
[0] = SHA1M_A
;
12141 pstoken
->pc_digest
[1] = SHA1M_B
;
12142 pstoken
->pc_digest
[2] = SHA1M_C
;
12143 pstoken
->pc_digest
[3] = SHA1M_D
;
12144 pstoken
->pc_digest
[4] = SHA1M_E
;
12146 pstoken
->pc_offset
= 0;
12148 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12152 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12153 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12154 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12155 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12156 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12157 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12158 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12159 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12160 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12161 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12162 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12163 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12164 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12165 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12166 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12167 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12169 sha1_64 (w
, pstoken
->pc_digest
);
12171 pstoken
->pc_offset
+= 16;
12174 return (PARSER_OK
);
12177 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12179 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12181 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12183 u32
*digest
= (u32
*) hash_buf
->digest
;
12185 u8 tmp_buf
[100] = { 0 };
12187 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12189 memcpy (digest
, tmp_buf
, 20);
12191 digest
[0] = byte_swap_32 (digest
[0]);
12192 digest
[1] = byte_swap_32 (digest
[1]);
12193 digest
[2] = byte_swap_32 (digest
[2]);
12194 digest
[3] = byte_swap_32 (digest
[3]);
12195 digest
[4] = byte_swap_32 (digest
[4]);
12197 digest
[0] -= SHA1M_A
;
12198 digest
[1] -= SHA1M_B
;
12199 digest
[2] -= SHA1M_C
;
12200 digest
[3] -= SHA1M_D
;
12201 digest
[4] -= SHA1M_E
;
12203 return (PARSER_OK
);
12206 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12208 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12210 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12212 u32
*digest
= (u32
*) hash_buf
->digest
;
12214 salt_t
*salt
= hash_buf
->salt
;
12216 u8 tmp_buf
[100] = { 0 };
12218 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12220 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12222 memcpy (digest
, tmp_buf
, 20);
12224 int salt_len
= tmp_len
- 20;
12226 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12228 salt
->salt_len
= salt_len
;
12230 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12232 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12234 char *ptr
= (char *) salt
->salt_buf
;
12236 ptr
[salt
->salt_len
] = 0x80;
12239 digest
[0] = byte_swap_32 (digest
[0]);
12240 digest
[1] = byte_swap_32 (digest
[1]);
12241 digest
[2] = byte_swap_32 (digest
[2]);
12242 digest
[3] = byte_swap_32 (digest
[3]);
12243 digest
[4] = byte_swap_32 (digest
[4]);
12245 digest
[0] -= SHA1M_A
;
12246 digest
[1] -= SHA1M_B
;
12247 digest
[2] -= SHA1M_C
;
12248 digest
[3] -= SHA1M_D
;
12249 digest
[4] -= SHA1M_E
;
12251 return (PARSER_OK
);
12254 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12256 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12258 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12260 u32
*digest
= (u32
*) hash_buf
->digest
;
12262 salt_t
*salt
= hash_buf
->salt
;
12264 char *salt_buf
= input_buf
+ 6;
12268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12274 salt
->salt_len
= salt_len
;
12276 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12278 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12279 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12280 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12281 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12282 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12284 digest
[0] -= SHA1M_A
;
12285 digest
[1] -= SHA1M_B
;
12286 digest
[2] -= SHA1M_C
;
12287 digest
[3] -= SHA1M_D
;
12288 digest
[4] -= SHA1M_E
;
12290 return (PARSER_OK
);
12293 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12295 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12297 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12299 u32
*digest
= (u32
*) hash_buf
->digest
;
12301 salt_t
*salt
= hash_buf
->salt
;
12303 char *salt_buf
= input_buf
+ 6;
12307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12313 salt
->salt_len
= salt_len
;
12315 char *hash_pos
= input_buf
+ 6 + 8;
12317 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12318 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12319 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12320 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12321 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12323 digest
[0] -= SHA1M_A
;
12324 digest
[1] -= SHA1M_B
;
12325 digest
[2] -= SHA1M_C
;
12326 digest
[3] -= SHA1M_D
;
12327 digest
[4] -= SHA1M_E
;
12329 return (PARSER_OK
);
12332 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12334 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12336 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12338 u64
*digest
= (u64
*) hash_buf
->digest
;
12340 salt_t
*salt
= hash_buf
->salt
;
12342 char *salt_buf
= input_buf
+ 6;
12346 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12348 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12350 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12352 salt
->salt_len
= salt_len
;
12354 char *hash_pos
= input_buf
+ 6 + 8;
12356 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12357 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12358 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12359 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12360 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12361 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12362 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12363 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12365 digest
[0] -= SHA512M_A
;
12366 digest
[1] -= SHA512M_B
;
12367 digest
[2] -= SHA512M_C
;
12368 digest
[3] -= SHA512M_D
;
12369 digest
[4] -= SHA512M_E
;
12370 digest
[5] -= SHA512M_F
;
12371 digest
[6] -= SHA512M_G
;
12372 digest
[7] -= SHA512M_H
;
12374 return (PARSER_OK
);
12377 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12381 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12385 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12388 u32
*digest
= (u32
*) hash_buf
->digest
;
12390 salt_t
*salt
= hash_buf
->salt
;
12392 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12393 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12397 digest
[0] = byte_swap_32 (digest
[0]);
12398 digest
[1] = byte_swap_32 (digest
[1]);
12400 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12402 uint salt_len
= input_len
- 16 - 1;
12404 char *salt_buf
= input_buf
+ 16 + 1;
12406 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12408 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12410 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12412 salt
->salt_len
= salt_len
;
12414 return (PARSER_OK
);
12417 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12419 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12421 u32
*digest
= (u32
*) hash_buf
->digest
;
12423 salt_t
*salt
= hash_buf
->salt
;
12425 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12426 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12427 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12428 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12429 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12431 digest
[0] -= SHA1M_A
;
12432 digest
[1] -= SHA1M_B
;
12433 digest
[2] -= SHA1M_C
;
12434 digest
[3] -= SHA1M_D
;
12435 digest
[4] -= SHA1M_E
;
12437 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12439 uint salt_len
= input_len
- 40 - 1;
12441 char *salt_buf
= input_buf
+ 40 + 1;
12443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12449 salt
->salt_len
= salt_len
;
12451 return (PARSER_OK
);
12454 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12456 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12458 u32
*digest
= (u32
*) hash_buf
->digest
;
12460 salt_t
*salt
= hash_buf
->salt
;
12462 char *hash_pos
= input_buf
;
12464 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12465 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12466 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12467 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12468 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12469 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12470 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12471 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12472 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12473 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12474 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12475 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12476 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12477 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12478 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12479 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12481 char *salt_pos
= input_buf
+ 128;
12483 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12484 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12485 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12486 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12488 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12489 salt
->salt_len
= 16;
12491 return (PARSER_OK
);
12494 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12496 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12498 u32
*digest
= (u32
*) hash_buf
->digest
;
12500 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12501 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12502 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12503 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12504 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12505 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12506 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12507 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12509 digest
[0] -= SHA256M_A
;
12510 digest
[1] -= SHA256M_B
;
12511 digest
[2] -= SHA256M_C
;
12512 digest
[3] -= SHA256M_D
;
12513 digest
[4] -= SHA256M_E
;
12514 digest
[5] -= SHA256M_F
;
12515 digest
[6] -= SHA256M_G
;
12516 digest
[7] -= SHA256M_H
;
12518 return (PARSER_OK
);
12521 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12523 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12525 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12529 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12532 u32
*digest
= (u32
*) hash_buf
->digest
;
12534 salt_t
*salt
= hash_buf
->salt
;
12536 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12537 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12538 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12539 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12540 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12541 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12542 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12543 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12545 digest
[0] -= SHA256M_A
;
12546 digest
[1] -= SHA256M_B
;
12547 digest
[2] -= SHA256M_C
;
12548 digest
[3] -= SHA256M_D
;
12549 digest
[4] -= SHA256M_E
;
12550 digest
[5] -= SHA256M_F
;
12551 digest
[6] -= SHA256M_G
;
12552 digest
[7] -= SHA256M_H
;
12554 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12556 uint salt_len
= input_len
- 64 - 1;
12558 char *salt_buf
= input_buf
+ 64 + 1;
12560 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12562 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12564 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12566 salt
->salt_len
= salt_len
;
12568 return (PARSER_OK
);
12571 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12573 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12575 u64
*digest
= (u64
*) hash_buf
->digest
;
12577 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12578 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12579 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12580 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12581 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12582 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12586 digest
[0] -= SHA384M_A
;
12587 digest
[1] -= SHA384M_B
;
12588 digest
[2] -= SHA384M_C
;
12589 digest
[3] -= SHA384M_D
;
12590 digest
[4] -= SHA384M_E
;
12591 digest
[5] -= SHA384M_F
;
12595 return (PARSER_OK
);
12598 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12600 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12602 u64
*digest
= (u64
*) hash_buf
->digest
;
12604 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12605 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12606 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12607 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12608 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12609 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12610 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12611 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12613 digest
[0] -= SHA512M_A
;
12614 digest
[1] -= SHA512M_B
;
12615 digest
[2] -= SHA512M_C
;
12616 digest
[3] -= SHA512M_D
;
12617 digest
[4] -= SHA512M_E
;
12618 digest
[5] -= SHA512M_F
;
12619 digest
[6] -= SHA512M_G
;
12620 digest
[7] -= SHA512M_H
;
12622 return (PARSER_OK
);
12625 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12627 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12629 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12633 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12636 u64
*digest
= (u64
*) hash_buf
->digest
;
12638 salt_t
*salt
= hash_buf
->salt
;
12640 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12641 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12642 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12643 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12644 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12645 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12646 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12647 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12649 digest
[0] -= SHA512M_A
;
12650 digest
[1] -= SHA512M_B
;
12651 digest
[2] -= SHA512M_C
;
12652 digest
[3] -= SHA512M_D
;
12653 digest
[4] -= SHA512M_E
;
12654 digest
[5] -= SHA512M_F
;
12655 digest
[6] -= SHA512M_G
;
12656 digest
[7] -= SHA512M_H
;
12658 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12660 uint salt_len
= input_len
- 128 - 1;
12662 char *salt_buf
= input_buf
+ 128 + 1;
12664 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12666 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12668 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12670 salt
->salt_len
= salt_len
;
12672 return (PARSER_OK
);
12675 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12677 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12679 u64
*digest
= (u64
*) hash_buf
->digest
;
12681 salt_t
*salt
= hash_buf
->salt
;
12683 char *salt_pos
= input_buf
+ 3;
12685 uint iterations_len
= 0;
12687 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12691 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12693 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12694 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12698 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12702 iterations_len
+= 8;
12706 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12709 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12711 char *hash_pos
= strchr (salt_pos
, '$');
12713 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12715 uint salt_len
= hash_pos
- salt_pos
;
12717 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12719 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12721 salt
->salt_len
= salt_len
;
12725 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12727 return (PARSER_OK
);
12730 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12732 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12734 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12736 u64
*digest
= (u64
*) hash_buf
->digest
;
12738 salt_t
*salt
= hash_buf
->salt
;
12740 uint keccak_mdlen
= input_len
/ 2;
12742 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12744 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12746 digest
[i
] = byte_swap_64 (digest
[i
]);
12749 salt
->keccak_mdlen
= keccak_mdlen
;
12751 return (PARSER_OK
);
12754 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12756 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12758 u32
*digest
= (u32
*) hash_buf
->digest
;
12760 salt_t
*salt
= hash_buf
->salt
;
12762 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12765 * Parse that strange long line
12770 size_t in_len
[9] = { 0 };
12772 in_off
[0] = strtok (input_buf
, ":");
12774 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12776 in_len
[0] = strlen (in_off
[0]);
12780 for (i
= 1; i
< 9; i
++)
12782 in_off
[i
] = strtok (NULL
, ":");
12784 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12786 in_len
[i
] = strlen (in_off
[i
]);
12789 char *ptr
= (char *) ikepsk
->msg_buf
;
12791 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12792 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12793 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12794 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12795 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12796 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12800 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12802 ptr
= (char *) ikepsk
->nr_buf
;
12804 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12805 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12809 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12812 * Store to database
12817 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12818 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12819 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12820 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12822 digest
[0] = byte_swap_32 (digest
[0]);
12823 digest
[1] = byte_swap_32 (digest
[1]);
12824 digest
[2] = byte_swap_32 (digest
[2]);
12825 digest
[3] = byte_swap_32 (digest
[3]);
12827 salt
->salt_len
= 32;
12829 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12830 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12831 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12832 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12833 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12834 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12835 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12836 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12838 return (PARSER_OK
);
12841 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12843 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12845 u32
*digest
= (u32
*) hash_buf
->digest
;
12847 salt_t
*salt
= hash_buf
->salt
;
12849 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12852 * Parse that strange long line
12857 size_t in_len
[9] = { 0 };
12859 in_off
[0] = strtok (input_buf
, ":");
12861 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12863 in_len
[0] = strlen (in_off
[0]);
12867 for (i
= 1; i
< 9; i
++)
12869 in_off
[i
] = strtok (NULL
, ":");
12871 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12873 in_len
[i
] = strlen (in_off
[i
]);
12876 char *ptr
= (char *) ikepsk
->msg_buf
;
12878 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12879 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12880 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12881 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12882 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12883 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12887 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12889 ptr
= (char *) ikepsk
->nr_buf
;
12891 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12892 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12896 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12899 * Store to database
12904 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12905 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12906 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12907 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12908 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12910 salt
->salt_len
= 32;
12912 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12913 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12914 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12915 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12916 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12917 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12918 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12919 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12921 return (PARSER_OK
);
12924 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12926 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) 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]);
12936 digest
[0] = byte_swap_32 (digest
[0]);
12937 digest
[1] = byte_swap_32 (digest
[1]);
12938 digest
[2] = byte_swap_32 (digest
[2]);
12939 digest
[3] = byte_swap_32 (digest
[3]);
12940 digest
[4] = byte_swap_32 (digest
[4]);
12942 return (PARSER_OK
);
12945 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12947 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12949 u32
*digest
= (u32
*) hash_buf
->digest
;
12951 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12952 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12953 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12954 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12955 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12956 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12957 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12958 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12959 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12960 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12961 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12962 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12963 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12964 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12965 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12966 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12968 return (PARSER_OK
);
12971 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12973 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12975 u32
*digest
= (u32
*) hash_buf
->digest
;
12977 salt_t
*salt
= hash_buf
->salt
;
12979 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12980 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12981 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12982 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12983 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12985 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12987 uint salt_len
= input_len
- 40 - 1;
12989 char *salt_buf
= input_buf
+ 40 + 1;
12991 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12993 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12995 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12997 salt
->salt_len
= salt_len
;
12999 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13001 return (PARSER_OK
);
13004 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13006 u32
*digest
= (u32
*) hash_buf
->digest
;
13008 salt_t
*salt
= hash_buf
->salt
;
13010 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13012 if (input_len
== 0)
13014 log_error ("TrueCrypt container not specified");
13019 FILE *fp
= fopen (input_buf
, "rb");
13023 log_error ("%s: %s", input_buf
, strerror (errno
));
13028 char buf
[512] = { 0 };
13030 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13034 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13036 memcpy (tc
->salt_buf
, buf
, 64);
13038 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13040 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13042 salt
->salt_len
= 4;
13044 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13046 tc
->signature
= 0x45555254; // "TRUE"
13048 digest
[0] = tc
->data_buf
[0];
13050 return (PARSER_OK
);
13053 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13055 u32
*digest
= (u32
*) hash_buf
->digest
;
13057 salt_t
*salt
= hash_buf
->salt
;
13059 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13061 if (input_len
== 0)
13063 log_error ("TrueCrypt container not specified");
13068 FILE *fp
= fopen (input_buf
, "rb");
13072 log_error ("%s: %s", input_buf
, strerror (errno
));
13077 char buf
[512] = { 0 };
13079 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13083 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13085 memcpy (tc
->salt_buf
, buf
, 64);
13087 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13089 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13091 salt
->salt_len
= 4;
13093 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13095 tc
->signature
= 0x45555254; // "TRUE"
13097 digest
[0] = tc
->data_buf
[0];
13099 return (PARSER_OK
);
13102 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13104 u32
*digest
= (u32
*) hash_buf
->digest
;
13106 salt_t
*salt
= hash_buf
->salt
;
13108 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13110 if (input_len
== 0)
13112 log_error ("VeraCrypt container not specified");
13117 FILE *fp
= fopen (input_buf
, "rb");
13121 log_error ("%s: %s", input_buf
, strerror (errno
));
13126 char buf
[512] = { 0 };
13128 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13132 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13134 memcpy (tc
->salt_buf
, buf
, 64);
13136 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13138 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13140 salt
->salt_len
= 4;
13142 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13144 tc
->signature
= 0x41524556; // "VERA"
13146 digest
[0] = tc
->data_buf
[0];
13148 return (PARSER_OK
);
13151 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13153 u32
*digest
= (u32
*) hash_buf
->digest
;
13155 salt_t
*salt
= hash_buf
->salt
;
13157 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13159 if (input_len
== 0)
13161 log_error ("VeraCrypt container not specified");
13166 FILE *fp
= fopen (input_buf
, "rb");
13170 log_error ("%s: %s", input_buf
, strerror (errno
));
13175 char buf
[512] = { 0 };
13177 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13181 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13183 memcpy (tc
->salt_buf
, buf
, 64);
13185 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13187 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13189 salt
->salt_len
= 4;
13191 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13193 tc
->signature
= 0x41524556; // "VERA"
13195 digest
[0] = tc
->data_buf
[0];
13197 return (PARSER_OK
);
13200 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13202 u32
*digest
= (u32
*) hash_buf
->digest
;
13204 salt_t
*salt
= hash_buf
->salt
;
13206 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13208 if (input_len
== 0)
13210 log_error ("VeraCrypt container not specified");
13215 FILE *fp
= fopen (input_buf
, "rb");
13219 log_error ("%s: %s", input_buf
, strerror (errno
));
13224 char buf
[512] = { 0 };
13226 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13230 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13232 memcpy (tc
->salt_buf
, buf
, 64);
13234 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13236 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13238 salt
->salt_len
= 4;
13240 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13242 tc
->signature
= 0x41524556; // "VERA"
13244 digest
[0] = tc
->data_buf
[0];
13246 return (PARSER_OK
);
13249 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13251 u32
*digest
= (u32
*) hash_buf
->digest
;
13253 salt_t
*salt
= hash_buf
->salt
;
13255 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13257 if (input_len
== 0)
13259 log_error ("VeraCrypt container not specified");
13264 FILE *fp
= fopen (input_buf
, "rb");
13268 log_error ("%s: %s", input_buf
, strerror (errno
));
13273 char buf
[512] = { 0 };
13275 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13279 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13281 memcpy (tc
->salt_buf
, buf
, 64);
13283 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13285 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13287 salt
->salt_len
= 4;
13289 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13291 tc
->signature
= 0x41524556; // "VERA"
13293 digest
[0] = tc
->data_buf
[0];
13295 return (PARSER_OK
);
13298 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13300 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13302 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13304 u32
*digest
= (u32
*) hash_buf
->digest
;
13306 salt_t
*salt
= hash_buf
->salt
;
13308 char *salt_pos
= input_buf
+ 6;
13310 char *hash_pos
= strchr (salt_pos
, '$');
13312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13314 uint salt_len
= hash_pos
- salt_pos
;
13316 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13318 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13320 salt
->salt_len
= salt_len
;
13322 salt
->salt_iter
= 1000;
13326 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13328 return (PARSER_OK
);
13331 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13333 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13335 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13337 u32
*digest
= (u32
*) hash_buf
->digest
;
13339 salt_t
*salt
= hash_buf
->salt
;
13341 char *iter_pos
= input_buf
+ 7;
13343 char *salt_pos
= strchr (iter_pos
, '$');
13345 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13349 char *hash_pos
= strchr (salt_pos
, '$');
13351 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13353 uint salt_len
= hash_pos
- salt_pos
;
13355 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13357 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13359 salt
->salt_len
= salt_len
;
13361 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13363 salt
->salt_sign
[0] = atoi (salt_iter
);
13365 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13369 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13371 digest
[0] = byte_swap_32 (digest
[0]);
13372 digest
[1] = byte_swap_32 (digest
[1]);
13373 digest
[2] = byte_swap_32 (digest
[2]);
13374 digest
[3] = byte_swap_32 (digest
[3]);
13375 digest
[4] = byte_swap_32 (digest
[4]);
13377 return (PARSER_OK
);
13380 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13382 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13384 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13386 u32
*digest
= (u32
*) hash_buf
->digest
;
13388 salt_t
*salt
= hash_buf
->salt
;
13390 char *iter_pos
= input_buf
+ 9;
13392 char *salt_pos
= strchr (iter_pos
, '$');
13394 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13398 char *hash_pos
= strchr (salt_pos
, '$');
13400 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13402 uint salt_len
= hash_pos
- salt_pos
;
13404 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13406 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13408 salt
->salt_len
= salt_len
;
13410 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13412 salt
->salt_sign
[0] = atoi (salt_iter
);
13414 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13418 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13420 digest
[0] = byte_swap_32 (digest
[0]);
13421 digest
[1] = byte_swap_32 (digest
[1]);
13422 digest
[2] = byte_swap_32 (digest
[2]);
13423 digest
[3] = byte_swap_32 (digest
[3]);
13424 digest
[4] = byte_swap_32 (digest
[4]);
13425 digest
[5] = byte_swap_32 (digest
[5]);
13426 digest
[6] = byte_swap_32 (digest
[6]);
13427 digest
[7] = byte_swap_32 (digest
[7]);
13429 return (PARSER_OK
);
13432 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13434 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13436 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13438 u64
*digest
= (u64
*) hash_buf
->digest
;
13440 salt_t
*salt
= hash_buf
->salt
;
13442 char *iter_pos
= input_buf
+ 9;
13444 char *salt_pos
= strchr (iter_pos
, '$');
13446 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13450 char *hash_pos
= strchr (salt_pos
, '$');
13452 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13454 uint salt_len
= hash_pos
- salt_pos
;
13456 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13458 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13460 salt
->salt_len
= salt_len
;
13462 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13464 salt
->salt_sign
[0] = atoi (salt_iter
);
13466 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13470 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13472 digest
[0] = byte_swap_64 (digest
[0]);
13473 digest
[1] = byte_swap_64 (digest
[1]);
13474 digest
[2] = byte_swap_64 (digest
[2]);
13475 digest
[3] = byte_swap_64 (digest
[3]);
13476 digest
[4] = byte_swap_64 (digest
[4]);
13477 digest
[5] = byte_swap_64 (digest
[5]);
13478 digest
[6] = byte_swap_64 (digest
[6]);
13479 digest
[7] = byte_swap_64 (digest
[7]);
13481 return (PARSER_OK
);
13484 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13486 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13488 u32
*digest
= (u32
*) hash_buf
->digest
;
13490 salt_t
*salt
= hash_buf
->salt
;
13492 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13498 char *iterations_pos
= input_buf
;
13500 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13502 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13504 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13506 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13510 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13512 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13514 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13516 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13518 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13520 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13525 * pbkdf2 iterations
13528 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13531 * handle salt encoding
13534 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13536 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13538 const char p0
= saltbuf_pos
[i
+ 0];
13539 const char p1
= saltbuf_pos
[i
+ 1];
13541 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13542 | hex_convert (p0
) << 4;
13545 salt
->salt_len
= saltbuf_len
/ 2;
13548 * handle cipher encoding
13551 uint
*tmp
= (uint
*) mymalloc (32);
13553 char *cipherbuf_ptr
= (char *) tmp
;
13555 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13557 const char p0
= cipherbuf_pos
[i
+ 0];
13558 const char p1
= cipherbuf_pos
[i
+ 1];
13560 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13561 | hex_convert (p0
) << 4;
13564 // iv is stored at salt_buf 4 (length 16)
13565 // data is stored at salt_buf 8 (length 16)
13567 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13568 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13569 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13570 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13572 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13573 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13574 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13575 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13579 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13581 const char p0
= cipherbuf_pos
[j
+ 0];
13582 const char p1
= cipherbuf_pos
[j
+ 1];
13584 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13585 | hex_convert (p0
) << 4;
13592 digest
[0] = 0x10101010;
13593 digest
[1] = 0x10101010;
13594 digest
[2] = 0x10101010;
13595 digest
[3] = 0x10101010;
13597 return (PARSER_OK
);
13600 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13602 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13604 u32
*digest
= (u32
*) hash_buf
->digest
;
13606 salt_t
*salt
= hash_buf
->salt
;
13608 char *hashbuf_pos
= input_buf
;
13610 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13612 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13614 uint hash_len
= iterations_pos
- hashbuf_pos
;
13616 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13620 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13622 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13624 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13628 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13630 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13634 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13636 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13638 salt
->salt_len
= salt_len
;
13640 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13642 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13643 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13644 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13645 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13647 return (PARSER_OK
);
13650 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13652 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13654 u32
*digest
= (u32
*) hash_buf
->digest
;
13656 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13657 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13658 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13659 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13660 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13661 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13662 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13663 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13665 digest
[0] = byte_swap_32 (digest
[0]);
13666 digest
[1] = byte_swap_32 (digest
[1]);
13667 digest
[2] = byte_swap_32 (digest
[2]);
13668 digest
[3] = byte_swap_32 (digest
[3]);
13669 digest
[4] = byte_swap_32 (digest
[4]);
13670 digest
[5] = byte_swap_32 (digest
[5]);
13671 digest
[6] = byte_swap_32 (digest
[6]);
13672 digest
[7] = byte_swap_32 (digest
[7]);
13674 return (PARSER_OK
);
13677 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13679 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13681 u32
*digest
= (u32
*) hash_buf
->digest
;
13683 salt_t
*salt
= hash_buf
->salt
;
13685 char *salt_pos
= input_buf
+ 3;
13687 uint iterations_len
= 0;
13689 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13693 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13695 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13696 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13700 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13704 iterations_len
+= 8;
13708 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13711 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13713 char *hash_pos
= strchr (salt_pos
, '$');
13715 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13717 uint salt_len
= hash_pos
- salt_pos
;
13719 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13721 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13723 salt
->salt_len
= salt_len
;
13727 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13729 return (PARSER_OK
);
13732 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13734 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13736 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13738 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13740 u64
*digest
= (u64
*) hash_buf
->digest
;
13742 salt_t
*salt
= hash_buf
->salt
;
13744 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13746 char *iter_pos
= input_buf
+ 4;
13748 char *salt_pos
= strchr (iter_pos
, '$');
13750 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13754 char *hash_pos
= strchr (salt_pos
, '$');
13756 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13758 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13762 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13763 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13764 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13765 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13766 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13767 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13768 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13769 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13771 uint salt_len
= hash_pos
- salt_pos
- 1;
13773 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13775 salt
->salt_len
= salt_len
/ 2;
13777 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13778 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13779 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13780 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13781 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13782 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13783 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13784 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13786 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13787 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13788 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13789 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13790 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13791 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13792 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13793 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13794 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13795 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13797 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13799 salt
->salt_iter
= atoi (iter_pos
) - 1;
13801 return (PARSER_OK
);
13804 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13806 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13808 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13810 u32
*digest
= (u32
*) hash_buf
->digest
;
13812 salt_t
*salt
= hash_buf
->salt
;
13814 char *salt_pos
= input_buf
+ 14;
13816 char *hash_pos
= strchr (salt_pos
, '*');
13818 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13822 uint salt_len
= hash_pos
- salt_pos
- 1;
13824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13826 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13830 salt
->salt_len
= salt_len
;
13832 u8 tmp_buf
[100] = { 0 };
13834 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13836 memcpy (digest
, tmp_buf
, 32);
13838 digest
[0] = byte_swap_32 (digest
[0]);
13839 digest
[1] = byte_swap_32 (digest
[1]);
13840 digest
[2] = byte_swap_32 (digest
[2]);
13841 digest
[3] = byte_swap_32 (digest
[3]);
13842 digest
[4] = byte_swap_32 (digest
[4]);
13843 digest
[5] = byte_swap_32 (digest
[5]);
13844 digest
[6] = byte_swap_32 (digest
[6]);
13845 digest
[7] = byte_swap_32 (digest
[7]);
13847 digest
[0] -= SHA256M_A
;
13848 digest
[1] -= SHA256M_B
;
13849 digest
[2] -= SHA256M_C
;
13850 digest
[3] -= SHA256M_D
;
13851 digest
[4] -= SHA256M_E
;
13852 digest
[5] -= SHA256M_F
;
13853 digest
[6] -= SHA256M_G
;
13854 digest
[7] -= SHA256M_H
;
13856 return (PARSER_OK
);
13859 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13861 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13863 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13865 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13867 u64
*digest
= (u64
*) hash_buf
->digest
;
13869 salt_t
*salt
= hash_buf
->salt
;
13871 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13873 char *iter_pos
= input_buf
+ 19;
13875 char *salt_pos
= strchr (iter_pos
, '.');
13877 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13881 char *hash_pos
= strchr (salt_pos
, '.');
13883 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13885 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13889 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13890 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13891 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13892 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13893 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13894 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13895 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13896 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13898 uint salt_len
= hash_pos
- salt_pos
- 1;
13902 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13906 for (i
= 0; i
< salt_len
; i
++)
13908 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13911 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13912 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13914 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13916 salt
->salt_len
= salt_len
;
13918 salt
->salt_iter
= atoi (iter_pos
) - 1;
13920 return (PARSER_OK
);
13923 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13925 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13927 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13929 u64
*digest
= (u64
*) hash_buf
->digest
;
13931 salt_t
*salt
= hash_buf
->salt
;
13933 u8 tmp_buf
[120] = { 0 };
13935 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13937 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13939 memcpy (digest
, tmp_buf
, 64);
13941 digest
[0] = byte_swap_64 (digest
[0]);
13942 digest
[1] = byte_swap_64 (digest
[1]);
13943 digest
[2] = byte_swap_64 (digest
[2]);
13944 digest
[3] = byte_swap_64 (digest
[3]);
13945 digest
[4] = byte_swap_64 (digest
[4]);
13946 digest
[5] = byte_swap_64 (digest
[5]);
13947 digest
[6] = byte_swap_64 (digest
[6]);
13948 digest
[7] = byte_swap_64 (digest
[7]);
13950 digest
[0] -= SHA512M_A
;
13951 digest
[1] -= SHA512M_B
;
13952 digest
[2] -= SHA512M_C
;
13953 digest
[3] -= SHA512M_D
;
13954 digest
[4] -= SHA512M_E
;
13955 digest
[5] -= SHA512M_F
;
13956 digest
[6] -= SHA512M_G
;
13957 digest
[7] -= SHA512M_H
;
13959 int salt_len
= tmp_len
- 64;
13961 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13963 salt
->salt_len
= salt_len
;
13965 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13967 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13969 char *ptr
= (char *) salt
->salt_buf
;
13971 ptr
[salt
->salt_len
] = 0x80;
13974 return (PARSER_OK
);
13977 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13979 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13981 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13985 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13988 u32
*digest
= (u32
*) hash_buf
->digest
;
13990 salt_t
*salt
= hash_buf
->salt
;
13992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13997 digest
[0] = byte_swap_32 (digest
[0]);
13998 digest
[1] = byte_swap_32 (digest
[1]);
13999 digest
[2] = byte_swap_32 (digest
[2]);
14000 digest
[3] = byte_swap_32 (digest
[3]);
14002 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14004 uint salt_len
= input_len
- 32 - 1;
14006 char *salt_buf
= input_buf
+ 32 + 1;
14008 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14010 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14012 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14014 salt
->salt_len
= salt_len
;
14016 return (PARSER_OK
);
14019 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14021 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14023 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14027 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14030 u32
*digest
= (u32
*) hash_buf
->digest
;
14032 salt_t
*salt
= hash_buf
->salt
;
14034 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14035 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14036 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14037 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14038 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14040 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14042 uint salt_len
= input_len
- 40 - 1;
14044 char *salt_buf
= input_buf
+ 40 + 1;
14046 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14048 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14050 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14052 salt
->salt_len
= salt_len
;
14054 return (PARSER_OK
);
14057 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14059 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14061 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14065 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14068 u32
*digest
= (u32
*) hash_buf
->digest
;
14070 salt_t
*salt
= hash_buf
->salt
;
14072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14074 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14075 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14076 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14077 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14078 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14079 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14081 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14083 uint salt_len
= input_len
- 64 - 1;
14085 char *salt_buf
= input_buf
+ 64 + 1;
14087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14089 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14091 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14093 salt
->salt_len
= salt_len
;
14095 return (PARSER_OK
);
14098 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14100 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14102 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14106 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14109 u64
*digest
= (u64
*) hash_buf
->digest
;
14111 salt_t
*salt
= hash_buf
->salt
;
14113 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14114 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14115 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14116 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14117 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14118 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14119 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14120 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14122 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14124 uint salt_len
= input_len
- 128 - 1;
14126 char *salt_buf
= input_buf
+ 128 + 1;
14128 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14130 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14132 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14134 salt
->salt_len
= salt_len
;
14136 return (PARSER_OK
);
14139 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14141 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14143 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14145 u32
*digest
= (u32
*) hash_buf
->digest
;
14147 salt_t
*salt
= hash_buf
->salt
;
14149 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14155 char *user_pos
= input_buf
+ 10 + 1;
14157 char *realm_pos
= strchr (user_pos
, '$');
14159 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14161 uint user_len
= realm_pos
- user_pos
;
14163 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14167 char *salt_pos
= strchr (realm_pos
, '$');
14169 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14171 uint realm_len
= salt_pos
- realm_pos
;
14173 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14177 char *data_pos
= strchr (salt_pos
, '$');
14179 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14181 uint salt_len
= data_pos
- salt_pos
;
14183 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14187 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14189 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14195 memcpy (krb5pa
->user
, user_pos
, user_len
);
14196 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14197 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14199 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14201 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14203 const char p0
= data_pos
[i
+ 0];
14204 const char p1
= data_pos
[i
+ 1];
14206 *timestamp_ptr
++ = hex_convert (p1
) << 0
14207 | hex_convert (p0
) << 4;
14210 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14212 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14214 const char p0
= data_pos
[i
+ 0];
14215 const char p1
= data_pos
[i
+ 1];
14217 *checksum_ptr
++ = hex_convert (p1
) << 0
14218 | hex_convert (p0
) << 4;
14222 * copy some data to generic buffers to make sorting happy
14225 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14226 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14227 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14228 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14229 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14230 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14231 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14232 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14233 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14235 salt
->salt_len
= 36;
14237 digest
[0] = krb5pa
->checksum
[0];
14238 digest
[1] = krb5pa
->checksum
[1];
14239 digest
[2] = krb5pa
->checksum
[2];
14240 digest
[3] = krb5pa
->checksum
[3];
14242 return (PARSER_OK
);
14245 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14247 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14249 u32
*digest
= (u32
*) hash_buf
->digest
;
14251 salt_t
*salt
= hash_buf
->salt
;
14257 char *salt_pos
= input_buf
;
14259 char *hash_pos
= strchr (salt_pos
, '$');
14261 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14263 uint salt_len
= hash_pos
- salt_pos
;
14265 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14269 uint hash_len
= input_len
- 1 - salt_len
;
14271 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14279 for (uint i
= 0; i
< salt_len
; i
++)
14281 if (salt_pos
[i
] == ' ') continue;
14286 // SAP user names cannot be longer than 12 characters
14287 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14289 // SAP user name cannot start with ! or ?
14290 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14298 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14302 salt
->salt_len
= salt_len
;
14304 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14305 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14309 digest
[0] = byte_swap_32 (digest
[0]);
14310 digest
[1] = byte_swap_32 (digest
[1]);
14312 return (PARSER_OK
);
14315 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14317 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14319 u32
*digest
= (u32
*) hash_buf
->digest
;
14321 salt_t
*salt
= hash_buf
->salt
;
14327 char *salt_pos
= input_buf
;
14329 char *hash_pos
= strchr (salt_pos
, '$');
14331 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14333 uint salt_len
= hash_pos
- salt_pos
;
14335 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14339 uint hash_len
= input_len
- 1 - salt_len
;
14341 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14349 for (uint i
= 0; i
< salt_len
; i
++)
14351 if (salt_pos
[i
] == ' ') continue;
14356 // SAP user names cannot be longer than 12 characters
14357 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14358 // so far nobody complained so we stay with this because it helps in optimization
14359 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14361 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14363 // SAP user name cannot start with ! or ?
14364 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14370 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14372 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14374 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14376 salt
->salt_len
= salt_len
;
14378 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14379 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14380 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14381 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14382 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14384 return (PARSER_OK
);
14387 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14389 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14391 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14393 u64
*digest
= (u64
*) hash_buf
->digest
;
14395 salt_t
*salt
= hash_buf
->salt
;
14397 char *iter_pos
= input_buf
+ 3;
14399 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14401 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14403 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14405 salt
->salt_iter
= salt_iter
;
14407 char *salt_pos
= iter_pos
+ 1;
14411 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14413 salt
->salt_len
= salt_len
;
14415 char *hash_pos
= salt_pos
+ salt_len
;
14417 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14421 char *tmp
= (char *) salt
->salt_buf_pc
;
14423 tmp
[0] = hash_pos
[42];
14427 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14428 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14429 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14430 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14436 return (PARSER_OK
);
14439 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14441 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14443 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14445 u32
*digest
= (u32
*) hash_buf
->digest
;
14447 salt_t
*salt
= hash_buf
->salt
;
14449 char *salt_buf
= input_buf
+ 6;
14451 uint salt_len
= 16;
14453 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14455 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14457 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14459 salt
->salt_len
= salt_len
;
14461 char *hash_pos
= input_buf
+ 6 + 16;
14463 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14464 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14465 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14466 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14467 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14468 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14469 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14470 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14472 return (PARSER_OK
);
14475 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14477 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14479 u32
*digest
= (u32
*) hash_buf
->digest
;
14481 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14482 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14486 return (PARSER_OK
);
14489 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14491 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14493 u32
*digest
= (u32
*) hash_buf
->digest
;
14495 salt_t
*salt
= hash_buf
->salt
;
14497 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14499 char *saltbuf_pos
= input_buf
;
14501 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14503 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14505 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14507 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14508 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14510 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14514 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14516 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14518 char *salt_ptr
= (char *) saltbuf_pos
;
14519 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14524 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14526 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14529 rakp_ptr
[j
] = 0x80;
14531 rakp
->salt_len
= j
;
14533 for (i
= 0; i
< 64; i
++)
14535 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14538 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14539 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14540 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14541 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14542 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14543 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14544 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14545 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14547 salt
->salt_len
= 32; // muss min. 32 haben
14549 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14550 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14551 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14552 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14553 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14555 return (PARSER_OK
);
14558 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14560 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14562 u32
*digest
= (u32
*) hash_buf
->digest
;
14564 salt_t
*salt
= hash_buf
->salt
;
14566 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14568 char *salt_pos
= input_buf
+ 1;
14570 memcpy (salt
->salt_buf
, salt_pos
, 8);
14572 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14573 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14575 salt
->salt_len
= 8;
14577 char *hash_pos
= salt_pos
+ 8;
14579 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14580 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14581 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14582 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14583 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14585 digest
[0] -= SHA1M_A
;
14586 digest
[1] -= SHA1M_B
;
14587 digest
[2] -= SHA1M_C
;
14588 digest
[3] -= SHA1M_D
;
14589 digest
[4] -= SHA1M_E
;
14591 return (PARSER_OK
);
14594 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14596 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14598 u32
*digest
= (u32
*) hash_buf
->digest
;
14600 salt_t
*salt
= hash_buf
->salt
;
14602 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14603 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14604 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14605 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14607 digest
[0] = byte_swap_32 (digest
[0]);
14608 digest
[1] = byte_swap_32 (digest
[1]);
14609 digest
[2] = byte_swap_32 (digest
[2]);
14610 digest
[3] = byte_swap_32 (digest
[3]);
14612 digest
[0] -= MD5M_A
;
14613 digest
[1] -= MD5M_B
;
14614 digest
[2] -= MD5M_C
;
14615 digest
[3] -= MD5M_D
;
14617 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14619 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14621 u32
*salt_buf
= salt
->salt_buf
;
14623 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14624 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14625 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14626 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14628 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14629 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14630 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14631 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14633 salt
->salt_len
= 16 + 1;
14635 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14637 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14639 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14641 return (PARSER_OK
);
14644 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14646 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14648 u32
*digest
= (u32
*) hash_buf
->digest
;
14650 salt_t
*salt
= hash_buf
->salt
;
14652 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14658 char *hashbuf_pos
= input_buf
;
14660 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14662 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14664 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14666 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14670 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14672 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14674 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14676 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14680 char *databuf_pos
= strchr (iteration_pos
, ':');
14682 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14684 const uint iteration_len
= databuf_pos
- iteration_pos
;
14686 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14687 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14689 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14691 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14692 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14698 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14699 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14700 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14701 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14702 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14703 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14704 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14705 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14709 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14711 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14713 const char p0
= saltbuf_pos
[i
+ 0];
14714 const char p1
= saltbuf_pos
[i
+ 1];
14716 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14717 | hex_convert (p0
) << 4;
14720 salt
->salt_buf
[4] = 0x01000000;
14721 salt
->salt_buf
[5] = 0x80;
14723 salt
->salt_len
= saltbuf_len
/ 2;
14727 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14731 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14733 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14735 const char p0
= databuf_pos
[i
+ 0];
14736 const char p1
= databuf_pos
[i
+ 1];
14738 *databuf_ptr
++ = hex_convert (p1
) << 0
14739 | hex_convert (p0
) << 4;
14742 *databuf_ptr
++ = 0x80;
14744 for (uint i
= 0; i
< 512; i
++)
14746 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14749 cloudkey
->data_len
= databuf_len
/ 2;
14751 return (PARSER_OK
);
14754 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14756 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14758 u32
*digest
= (u32
*) hash_buf
->digest
;
14760 salt_t
*salt
= hash_buf
->salt
;
14766 char *hashbuf_pos
= input_buf
;
14768 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14770 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14772 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14774 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14778 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14780 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14782 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14784 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14786 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14790 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14792 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14794 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14796 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14798 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14802 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14804 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14805 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14807 // ok, the plan for this algorithm is the following:
14808 // we have 2 salts here, the domain-name and a random salt
14809 // while both are used in the initial transformation,
14810 // only the random salt is used in the following iterations
14811 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14812 // and one that includes only the real salt (stored into salt_buf[]).
14813 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14815 u8 tmp_buf
[100] = { 0 };
14817 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14819 memcpy (digest
, tmp_buf
, 20);
14821 digest
[0] = byte_swap_32 (digest
[0]);
14822 digest
[1] = byte_swap_32 (digest
[1]);
14823 digest
[2] = byte_swap_32 (digest
[2]);
14824 digest
[3] = byte_swap_32 (digest
[3]);
14825 digest
[4] = byte_swap_32 (digest
[4]);
14829 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14831 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14833 char *len_ptr
= NULL
;
14835 for (uint i
= 0; i
< domainbuf_len
; i
++)
14837 if (salt_buf_pc_ptr
[i
] == '.')
14839 len_ptr
= &salt_buf_pc_ptr
[i
];
14849 salt
->salt_buf_pc
[7] = domainbuf_len
;
14853 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14855 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14857 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14859 salt
->salt_len
= salt_len
;
14863 salt
->salt_iter
= atoi (iteration_pos
);
14865 return (PARSER_OK
);
14868 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14870 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14872 u32
*digest
= (u32
*) hash_buf
->digest
;
14874 salt_t
*salt
= hash_buf
->salt
;
14876 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14877 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14878 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14879 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14880 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14882 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14884 uint salt_len
= input_len
- 40 - 1;
14886 char *salt_buf
= input_buf
+ 40 + 1;
14888 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14890 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14892 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14894 salt
->salt_len
= salt_len
;
14896 return (PARSER_OK
);
14899 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14901 const u8 ascii_to_ebcdic
[] =
14903 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14904 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14905 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14906 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14907 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14908 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14909 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14910 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14911 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14912 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14913 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14914 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14915 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14916 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14917 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14918 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14921 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14923 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14925 u32
*digest
= (u32
*) hash_buf
->digest
;
14927 salt_t
*salt
= hash_buf
->salt
;
14929 char *salt_pos
= input_buf
+ 6 + 1;
14931 char *digest_pos
= strchr (salt_pos
, '*');
14933 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14935 uint salt_len
= digest_pos
- salt_pos
;
14937 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14939 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14941 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14945 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14946 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14948 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14950 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14952 salt
->salt_len
= salt_len
;
14954 for (uint i
= 0; i
< salt_len
; i
++)
14956 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14958 for (uint i
= salt_len
; i
< 8; i
++)
14960 salt_buf_pc_ptr
[i
] = 0x40;
14965 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14967 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14968 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14970 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14971 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14973 digest
[0] = byte_swap_32 (digest
[0]);
14974 digest
[1] = byte_swap_32 (digest
[1]);
14976 IP (digest
[0], digest
[1], tt
);
14978 digest
[0] = rotr32 (digest
[0], 29);
14979 digest
[1] = rotr32 (digest
[1], 29);
14983 return (PARSER_OK
);
14986 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14988 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14990 u32
*digest
= (u32
*) hash_buf
->digest
;
14992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14997 digest
[0] = byte_swap_32 (digest
[0]);
14998 digest
[1] = byte_swap_32 (digest
[1]);
14999 digest
[2] = byte_swap_32 (digest
[2]);
15000 digest
[3] = byte_swap_32 (digest
[3]);
15002 return (PARSER_OK
);
15005 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15007 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15009 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15011 u32
*digest
= (u32
*) hash_buf
->digest
;
15013 salt_t
*salt
= hash_buf
->salt
;
15015 u8 tmp_buf
[120] = { 0 };
15017 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15019 tmp_buf
[3] += -4; // dont ask!
15021 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15023 salt
->salt_len
= 5;
15025 memcpy (digest
, tmp_buf
+ 5, 9);
15027 // yes, only 9 byte are needed to crack, but 10 to display
15029 salt
->salt_buf_pc
[7] = input_buf
[20];
15031 return (PARSER_OK
);
15034 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15036 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15038 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15040 u32
*digest
= (u32
*) hash_buf
->digest
;
15042 salt_t
*salt
= hash_buf
->salt
;
15044 u8 tmp_buf
[120] = { 0 };
15046 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15048 tmp_buf
[3] += -4; // dont ask!
15052 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15054 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)
15058 char tmp_iter_buf
[11] = { 0 };
15060 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15062 tmp_iter_buf
[10] = 0;
15064 salt
->salt_iter
= atoi (tmp_iter_buf
);
15066 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15068 return (PARSER_SALT_ITERATION
);
15071 salt
->salt_iter
--; // first round in init
15073 // 2 additional bytes for display only
15075 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15076 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15080 memcpy (digest
, tmp_buf
+ 28, 8);
15082 digest
[0] = byte_swap_32 (digest
[0]);
15083 digest
[1] = byte_swap_32 (digest
[1]);
15087 return (PARSER_OK
);
15090 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15092 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15094 u32
*digest
= (u32
*) hash_buf
->digest
;
15096 salt_t
*salt
= hash_buf
->salt
;
15098 char *salt_buf_pos
= input_buf
;
15100 char *hash_buf_pos
= salt_buf_pos
+ 6;
15102 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15103 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15104 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15105 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15106 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15107 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15108 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15109 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15111 digest
[0] -= SHA256M_A
;
15112 digest
[1] -= SHA256M_B
;
15113 digest
[2] -= SHA256M_C
;
15114 digest
[3] -= SHA256M_D
;
15115 digest
[4] -= SHA256M_E
;
15116 digest
[5] -= SHA256M_F
;
15117 digest
[6] -= SHA256M_G
;
15118 digest
[7] -= SHA256M_H
;
15120 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15122 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15124 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15126 salt
->salt_len
= salt_len
;
15128 return (PARSER_OK
);
15131 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15133 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15135 u32
*digest
= (u32
*) hash_buf
->digest
;
15137 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15139 salt_t
*salt
= hash_buf
->salt
;
15141 char *salt_buf
= input_buf
+ 6;
15143 char *digest_buf
= strchr (salt_buf
, '$');
15145 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15147 uint salt_len
= digest_buf
- salt_buf
;
15149 digest_buf
++; // skip the '$' symbol
15151 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15153 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15155 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15157 salt
->salt_len
= salt_len
;
15159 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15160 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15161 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15162 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15164 digest
[0] = byte_swap_32 (digest
[0]);
15165 digest
[1] = byte_swap_32 (digest
[1]);
15166 digest
[2] = byte_swap_32 (digest
[2]);
15167 digest
[3] = byte_swap_32 (digest
[3]);
15169 digest
[0] -= MD5M_A
;
15170 digest
[1] -= MD5M_B
;
15171 digest
[2] -= MD5M_C
;
15172 digest
[3] -= MD5M_D
;
15174 return (PARSER_OK
);
15177 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15179 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15181 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15183 u32
*digest
= (u32
*) hash_buf
->digest
;
15185 salt_t
*salt
= hash_buf
->salt
;
15187 char *salt_buf
= input_buf
+ 3;
15189 char *digest_buf
= strchr (salt_buf
, '$');
15191 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15193 uint salt_len
= digest_buf
- salt_buf
;
15195 digest_buf
++; // skip the '$' symbol
15197 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15199 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15201 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15203 salt_buf_ptr
[salt_len
] = 0x2d;
15205 salt
->salt_len
= salt_len
+ 1;
15207 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15208 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15209 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15210 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15212 digest
[0] = byte_swap_32 (digest
[0]);
15213 digest
[1] = byte_swap_32 (digest
[1]);
15214 digest
[2] = byte_swap_32 (digest
[2]);
15215 digest
[3] = byte_swap_32 (digest
[3]);
15217 digest
[0] -= MD5M_A
;
15218 digest
[1] -= MD5M_B
;
15219 digest
[2] -= MD5M_C
;
15220 digest
[3] -= MD5M_D
;
15222 return (PARSER_OK
);
15225 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15227 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15229 u32
*digest
= (u32
*) hash_buf
->digest
;
15231 salt_t
*salt
= hash_buf
->salt
;
15233 u8 tmp_buf
[100] = { 0 };
15235 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15237 memcpy (digest
, tmp_buf
, 20);
15239 digest
[0] = byte_swap_32 (digest
[0]);
15240 digest
[1] = byte_swap_32 (digest
[1]);
15241 digest
[2] = byte_swap_32 (digest
[2]);
15242 digest
[3] = byte_swap_32 (digest
[3]);
15243 digest
[4] = byte_swap_32 (digest
[4]);
15245 digest
[0] -= SHA1M_A
;
15246 digest
[1] -= SHA1M_B
;
15247 digest
[2] -= SHA1M_C
;
15248 digest
[3] -= SHA1M_D
;
15249 digest
[4] -= SHA1M_E
;
15251 salt
->salt_buf
[0] = 0x80;
15253 salt
->salt_len
= 0;
15255 return (PARSER_OK
);
15258 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15260 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15262 u32
*digest
= (u32
*) hash_buf
->digest
;
15264 salt_t
*salt
= hash_buf
->salt
;
15266 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15267 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15268 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15269 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15271 digest
[0] = byte_swap_32 (digest
[0]);
15272 digest
[1] = byte_swap_32 (digest
[1]);
15273 digest
[2] = byte_swap_32 (digest
[2]);
15274 digest
[3] = byte_swap_32 (digest
[3]);
15276 digest
[0] -= MD5M_A
;
15277 digest
[1] -= MD5M_B
;
15278 digest
[2] -= MD5M_C
;
15279 digest
[3] -= MD5M_D
;
15281 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15283 uint salt_len
= input_len
- 32 - 1;
15285 char *salt_buf
= input_buf
+ 32 + 1;
15287 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15289 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15291 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15294 * add static "salt" part
15297 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15301 salt
->salt_len
= salt_len
;
15303 return (PARSER_OK
);
15306 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15308 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15310 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15312 u32
*digest
= (u32
*) hash_buf
->digest
;
15314 salt_t
*salt
= hash_buf
->salt
;
15316 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15322 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15324 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15326 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15328 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15330 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15334 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15336 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15338 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15340 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15344 char *keybuf_pos
= strchr (keylen_pos
, '$');
15346 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15348 uint keylen_len
= keybuf_pos
- keylen_pos
;
15350 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15354 char *databuf_pos
= strchr (keybuf_pos
, '$');
15356 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15358 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15360 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15364 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15366 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15372 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15373 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15374 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15375 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15377 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15378 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15379 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15380 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15382 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15383 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15384 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15385 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15387 salt
->salt_len
= 16;
15388 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15390 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15392 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15395 return (PARSER_OK
);
15398 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15400 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15402 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15404 u32
*digest
= (u32
*) hash_buf
->digest
;
15406 salt_t
*salt
= hash_buf
->salt
;
15412 // first is the N salt parameter
15414 char *N_pos
= input_buf
+ 6;
15416 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15420 salt
->scrypt_N
= atoi (N_pos
);
15424 char *r_pos
= strchr (N_pos
, ':');
15426 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15430 salt
->scrypt_r
= atoi (r_pos
);
15434 char *p_pos
= strchr (r_pos
, ':');
15436 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15440 salt
->scrypt_p
= atoi (p_pos
);
15444 char *saltbuf_pos
= strchr (p_pos
, ':');
15446 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15450 char *hash_pos
= strchr (saltbuf_pos
, ':');
15452 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15458 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15460 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15462 u8 tmp_buf
[33] = { 0 };
15464 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15466 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15468 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15470 salt
->salt_len
= tmp_len
;
15471 salt
->salt_iter
= 1;
15473 // digest - base64 decode
15475 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15477 tmp_len
= input_len
- (hash_pos
- input_buf
);
15479 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15481 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15483 memcpy (digest
, tmp_buf
, 32);
15485 return (PARSER_OK
);
15488 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15490 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15492 u32
*digest
= (u32
*) hash_buf
->digest
;
15494 salt_t
*salt
= hash_buf
->salt
;
15500 char decrypted
[76] = { 0 }; // iv + hash
15502 juniper_decrypt_hash (input_buf
, decrypted
);
15504 char *md5crypt_hash
= decrypted
+ 12;
15506 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15508 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15510 char *salt_pos
= md5crypt_hash
+ 3;
15512 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15514 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15516 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15520 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15522 return (PARSER_OK
);
15525 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15527 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15529 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15531 u32
*digest
= (u32
*) hash_buf
->digest
;
15533 salt_t
*salt
= hash_buf
->salt
;
15535 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15541 // first is *raw* salt
15543 char *salt_pos
= input_buf
+ 3;
15545 char *hash_pos
= strchr (salt_pos
, '$');
15547 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15549 uint salt_len
= hash_pos
- salt_pos
;
15551 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15555 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15557 memcpy (salt_buf_ptr
, salt_pos
, 14);
15559 salt_buf_ptr
[17] = 0x01;
15560 salt_buf_ptr
[18] = 0x80;
15562 // add some stuff to normal salt to make sorted happy
15564 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15565 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15566 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15567 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15569 salt
->salt_len
= salt_len
;
15570 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15572 // base64 decode hash
15574 u8 tmp_buf
[100] = { 0 };
15576 uint hash_len
= input_len
- 3 - salt_len
- 1;
15578 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15580 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15582 memcpy (digest
, tmp_buf
, 32);
15584 digest
[0] = byte_swap_32 (digest
[0]);
15585 digest
[1] = byte_swap_32 (digest
[1]);
15586 digest
[2] = byte_swap_32 (digest
[2]);
15587 digest
[3] = byte_swap_32 (digest
[3]);
15588 digest
[4] = byte_swap_32 (digest
[4]);
15589 digest
[5] = byte_swap_32 (digest
[5]);
15590 digest
[6] = byte_swap_32 (digest
[6]);
15591 digest
[7] = byte_swap_32 (digest
[7]);
15593 return (PARSER_OK
);
15596 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15598 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15600 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15602 u32
*digest
= (u32
*) hash_buf
->digest
;
15604 salt_t
*salt
= hash_buf
->salt
;
15610 // first is *raw* salt
15612 char *salt_pos
= input_buf
+ 3;
15614 char *hash_pos
= strchr (salt_pos
, '$');
15616 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15618 uint salt_len
= hash_pos
- salt_pos
;
15620 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15622 salt
->salt_len
= salt_len
;
15625 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15627 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15628 salt_buf_ptr
[salt_len
] = 0;
15630 // base64 decode hash
15632 u8 tmp_buf
[100] = { 0 };
15634 uint hash_len
= input_len
- 3 - salt_len
- 1;
15636 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15638 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15640 memcpy (digest
, tmp_buf
, 32);
15643 salt
->scrypt_N
= 16384;
15644 salt
->scrypt_r
= 1;
15645 salt
->scrypt_p
= 1;
15646 salt
->salt_iter
= 1;
15648 return (PARSER_OK
);
15651 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15653 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15655 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15657 u32
*digest
= (u32
*) hash_buf
->digest
;
15659 salt_t
*salt
= hash_buf
->salt
;
15661 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15667 char *version_pos
= input_buf
+ 8 + 1;
15669 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15671 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15673 u32 version_len
= verifierHashSize_pos
- version_pos
;
15675 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15677 verifierHashSize_pos
++;
15679 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15681 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15683 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15685 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15689 char *saltSize_pos
= strchr (keySize_pos
, '*');
15691 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15693 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15695 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15699 char *osalt_pos
= strchr (saltSize_pos
, '*');
15701 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15703 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15705 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15709 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15711 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15713 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15715 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15717 encryptedVerifier_pos
++;
15719 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15721 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15723 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15725 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15727 encryptedVerifierHash_pos
++;
15729 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;
15731 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15733 const uint version
= atoi (version_pos
);
15735 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15737 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15739 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15741 const uint keySize
= atoi (keySize_pos
);
15743 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15745 office2007
->keySize
= keySize
;
15747 const uint saltSize
= atoi (saltSize_pos
);
15749 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15755 salt
->salt_len
= 16;
15756 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15758 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15759 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15760 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15761 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15767 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15768 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15769 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15770 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15772 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15773 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15774 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15775 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15776 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15782 digest
[0] = office2007
->encryptedVerifierHash
[0];
15783 digest
[1] = office2007
->encryptedVerifierHash
[1];
15784 digest
[2] = office2007
->encryptedVerifierHash
[2];
15785 digest
[3] = office2007
->encryptedVerifierHash
[3];
15787 return (PARSER_OK
);
15790 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15792 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15794 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15796 u32
*digest
= (u32
*) hash_buf
->digest
;
15798 salt_t
*salt
= hash_buf
->salt
;
15800 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15806 char *version_pos
= input_buf
+ 8 + 1;
15808 char *spinCount_pos
= strchr (version_pos
, '*');
15810 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15812 u32 version_len
= spinCount_pos
- version_pos
;
15814 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15818 char *keySize_pos
= strchr (spinCount_pos
, '*');
15820 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15822 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15824 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15828 char *saltSize_pos
= strchr (keySize_pos
, '*');
15830 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15832 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15834 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15838 char *osalt_pos
= strchr (saltSize_pos
, '*');
15840 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15842 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15844 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15848 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15850 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15852 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15854 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15856 encryptedVerifier_pos
++;
15858 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15860 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15862 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15864 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15866 encryptedVerifierHash_pos
++;
15868 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;
15870 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15872 const uint version
= atoi (version_pos
);
15874 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15876 const uint spinCount
= atoi (spinCount_pos
);
15878 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15880 const uint keySize
= atoi (keySize_pos
);
15882 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15884 const uint saltSize
= atoi (saltSize_pos
);
15886 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15892 salt
->salt_len
= 16;
15893 salt
->salt_iter
= spinCount
;
15895 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15896 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15897 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15898 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15904 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15905 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15906 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15907 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15909 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15910 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15911 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15912 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15913 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15914 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15915 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15916 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15922 digest
[0] = office2010
->encryptedVerifierHash
[0];
15923 digest
[1] = office2010
->encryptedVerifierHash
[1];
15924 digest
[2] = office2010
->encryptedVerifierHash
[2];
15925 digest
[3] = office2010
->encryptedVerifierHash
[3];
15927 return (PARSER_OK
);
15930 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15932 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15934 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15936 u32
*digest
= (u32
*) hash_buf
->digest
;
15938 salt_t
*salt
= hash_buf
->salt
;
15940 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15946 char *version_pos
= input_buf
+ 8 + 1;
15948 char *spinCount_pos
= strchr (version_pos
, '*');
15950 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15952 u32 version_len
= spinCount_pos
- version_pos
;
15954 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15958 char *keySize_pos
= strchr (spinCount_pos
, '*');
15960 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15962 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15964 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15968 char *saltSize_pos
= strchr (keySize_pos
, '*');
15970 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15972 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15974 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15978 char *osalt_pos
= strchr (saltSize_pos
, '*');
15980 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15982 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15984 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15988 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15990 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15992 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15994 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15996 encryptedVerifier_pos
++;
15998 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16000 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16002 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16004 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16006 encryptedVerifierHash_pos
++;
16008 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16010 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16012 const uint version
= atoi (version_pos
);
16014 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16016 const uint spinCount
= atoi (spinCount_pos
);
16018 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16020 const uint keySize
= atoi (keySize_pos
);
16022 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16024 const uint saltSize
= atoi (saltSize_pos
);
16026 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16032 salt
->salt_len
= 16;
16033 salt
->salt_iter
= spinCount
;
16035 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16036 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16037 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16038 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16044 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16045 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16046 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16047 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16049 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16050 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16051 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16052 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16053 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16054 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16055 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16056 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16062 digest
[0] = office2013
->encryptedVerifierHash
[0];
16063 digest
[1] = office2013
->encryptedVerifierHash
[1];
16064 digest
[2] = office2013
->encryptedVerifierHash
[2];
16065 digest
[3] = office2013
->encryptedVerifierHash
[3];
16067 return (PARSER_OK
);
16070 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16072 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16074 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16076 u32
*digest
= (u32
*) hash_buf
->digest
;
16078 salt_t
*salt
= hash_buf
->salt
;
16080 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16086 char *version_pos
= input_buf
+ 11;
16088 char *osalt_pos
= strchr (version_pos
, '*');
16090 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16092 u32 version_len
= osalt_pos
- version_pos
;
16094 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16098 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16100 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16102 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16104 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16106 encryptedVerifier_pos
++;
16108 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16110 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16112 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16114 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16116 encryptedVerifierHash_pos
++;
16118 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16120 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16122 const uint version
= *version_pos
- 0x30;
16124 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16130 oldoffice01
->version
= version
;
16132 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16133 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16134 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16135 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16137 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16138 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16139 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16140 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16142 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16143 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16144 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16145 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16147 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16148 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16149 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16150 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16156 salt
->salt_len
= 16;
16158 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16159 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16160 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16161 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16163 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16164 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16165 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16166 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16168 // this is a workaround as office produces multiple documents with the same salt
16170 salt
->salt_len
+= 32;
16172 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16173 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16174 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16175 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16176 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16177 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16178 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16179 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16185 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16186 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16187 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16188 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16190 return (PARSER_OK
);
16193 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16195 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16198 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16200 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16202 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16204 u32
*digest
= (u32
*) hash_buf
->digest
;
16206 salt_t
*salt
= hash_buf
->salt
;
16208 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16214 char *version_pos
= input_buf
+ 11;
16216 char *osalt_pos
= strchr (version_pos
, '*');
16218 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16220 u32 version_len
= osalt_pos
- version_pos
;
16222 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16226 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16228 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16230 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16232 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16234 encryptedVerifier_pos
++;
16236 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16238 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16240 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16242 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16244 encryptedVerifierHash_pos
++;
16246 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16248 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16250 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16252 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16256 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16258 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16260 const uint version
= *version_pos
- 0x30;
16262 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16268 oldoffice01
->version
= version
;
16270 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16271 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16272 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16273 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16275 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16276 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16277 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16278 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16280 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16281 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16282 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16283 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16285 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16286 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16287 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16288 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16290 oldoffice01
->rc4key
[1] = 0;
16291 oldoffice01
->rc4key
[0] = 0;
16293 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16294 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16295 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16296 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16297 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16298 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16299 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16300 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16301 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16302 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16304 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16305 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16311 salt
->salt_len
= 16;
16313 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16314 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16315 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16316 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16318 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16319 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16320 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16321 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16323 // this is a workaround as office produces multiple documents with the same salt
16325 salt
->salt_len
+= 32;
16327 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16328 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16329 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16330 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16331 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16332 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16333 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16334 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16340 digest
[0] = oldoffice01
->rc4key
[0];
16341 digest
[1] = oldoffice01
->rc4key
[1];
16345 return (PARSER_OK
);
16348 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16350 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16352 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16354 u32
*digest
= (u32
*) hash_buf
->digest
;
16356 salt_t
*salt
= hash_buf
->salt
;
16358 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16364 char *version_pos
= input_buf
+ 11;
16366 char *osalt_pos
= strchr (version_pos
, '*');
16368 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16370 u32 version_len
= osalt_pos
- version_pos
;
16372 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16376 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16378 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16380 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16382 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16384 encryptedVerifier_pos
++;
16386 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16388 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16392 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16394 encryptedVerifierHash_pos
++;
16396 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16398 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16400 const uint version
= *version_pos
- 0x30;
16402 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16408 oldoffice34
->version
= version
;
16410 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16411 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16412 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16413 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16415 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16416 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16417 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16418 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16420 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16421 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16422 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16423 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16424 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16426 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16427 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16428 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16429 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16430 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16436 salt
->salt_len
= 16;
16438 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16439 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16440 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16441 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16443 // this is a workaround as office produces multiple documents with the same salt
16445 salt
->salt_len
+= 32;
16447 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16448 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16449 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16450 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16451 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16452 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16453 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16454 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16460 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16461 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16462 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16463 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16465 return (PARSER_OK
);
16468 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16470 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16472 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16475 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16477 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16479 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16481 u32
*digest
= (u32
*) hash_buf
->digest
;
16483 salt_t
*salt
= hash_buf
->salt
;
16485 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16491 char *version_pos
= input_buf
+ 11;
16493 char *osalt_pos
= strchr (version_pos
, '*');
16495 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16497 u32 version_len
= osalt_pos
- version_pos
;
16499 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16503 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16505 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16507 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16509 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16511 encryptedVerifier_pos
++;
16513 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16515 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16517 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16519 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16521 encryptedVerifierHash_pos
++;
16523 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16525 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16527 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16529 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16533 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16535 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16537 const uint version
= *version_pos
- 0x30;
16539 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16545 oldoffice34
->version
= version
;
16547 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16548 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16549 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16550 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16552 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16553 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16554 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16555 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16557 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16558 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16559 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16560 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16561 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16563 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16564 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16565 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16566 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16567 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16569 oldoffice34
->rc4key
[1] = 0;
16570 oldoffice34
->rc4key
[0] = 0;
16572 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16573 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16574 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16575 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16576 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16577 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16578 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16579 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16580 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16581 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16583 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16584 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16590 salt
->salt_len
= 16;
16592 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16593 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16594 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16595 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16597 // this is a workaround as office produces multiple documents with the same salt
16599 salt
->salt_len
+= 32;
16601 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16602 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16603 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16604 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16605 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16606 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16607 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16608 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16614 digest
[0] = oldoffice34
->rc4key
[0];
16615 digest
[1] = oldoffice34
->rc4key
[1];
16619 return (PARSER_OK
);
16622 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16624 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16626 u32
*digest
= (u32
*) hash_buf
->digest
;
16628 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16629 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16630 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16631 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16633 digest
[0] = byte_swap_32 (digest
[0]);
16634 digest
[1] = byte_swap_32 (digest
[1]);
16635 digest
[2] = byte_swap_32 (digest
[2]);
16636 digest
[3] = byte_swap_32 (digest
[3]);
16638 return (PARSER_OK
);
16641 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16643 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16645 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16647 u32
*digest
= (u32
*) hash_buf
->digest
;
16649 salt_t
*salt
= hash_buf
->salt
;
16651 char *signature_pos
= input_buf
;
16653 char *salt_pos
= strchr (signature_pos
, '$');
16655 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16657 u32 signature_len
= salt_pos
- signature_pos
;
16659 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16663 char *hash_pos
= strchr (salt_pos
, '$');
16665 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16667 u32 salt_len
= hash_pos
- salt_pos
;
16669 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16673 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16675 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16677 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16678 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16679 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16680 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16681 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16683 digest
[0] -= SHA1M_A
;
16684 digest
[1] -= SHA1M_B
;
16685 digest
[2] -= SHA1M_C
;
16686 digest
[3] -= SHA1M_D
;
16687 digest
[4] -= SHA1M_E
;
16689 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16691 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16693 salt
->salt_len
= salt_len
;
16695 return (PARSER_OK
);
16698 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16700 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16702 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16704 u32
*digest
= (u32
*) hash_buf
->digest
;
16706 salt_t
*salt
= hash_buf
->salt
;
16708 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16714 char *iter_pos
= input_buf
+ 14;
16716 const int iter
= atoi (iter_pos
);
16718 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16720 salt
->salt_iter
= iter
- 1;
16722 char *salt_pos
= strchr (iter_pos
, '$');
16724 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16728 char *hash_pos
= strchr (salt_pos
, '$');
16730 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16732 const uint salt_len
= hash_pos
- salt_pos
;
16736 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16738 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16740 salt
->salt_len
= salt_len
;
16742 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16743 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16745 // add some stuff to normal salt to make sorted happy
16747 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16748 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16749 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16750 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16751 salt
->salt_buf
[4] = salt
->salt_iter
;
16753 // base64 decode hash
16755 u8 tmp_buf
[100] = { 0 };
16757 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16759 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16761 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16763 memcpy (digest
, tmp_buf
, 32);
16765 digest
[0] = byte_swap_32 (digest
[0]);
16766 digest
[1] = byte_swap_32 (digest
[1]);
16767 digest
[2] = byte_swap_32 (digest
[2]);
16768 digest
[3] = byte_swap_32 (digest
[3]);
16769 digest
[4] = byte_swap_32 (digest
[4]);
16770 digest
[5] = byte_swap_32 (digest
[5]);
16771 digest
[6] = byte_swap_32 (digest
[6]);
16772 digest
[7] = byte_swap_32 (digest
[7]);
16774 return (PARSER_OK
);
16777 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16779 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16781 u32
*digest
= (u32
*) hash_buf
->digest
;
16783 salt_t
*salt
= hash_buf
->salt
;
16785 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16786 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16790 digest
[0] = byte_swap_32 (digest
[0]);
16791 digest
[1] = byte_swap_32 (digest
[1]);
16793 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16794 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16795 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16797 char iter_c
= input_buf
[17];
16798 char iter_d
= input_buf
[19];
16800 // atm only defaults, let's see if there's more request
16801 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16802 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16804 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16806 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16807 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16808 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16809 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16811 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16812 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16813 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16814 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16816 salt
->salt_len
= 16;
16818 return (PARSER_OK
);
16821 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16823 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16825 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16827 u32
*digest
= (u32
*) hash_buf
->digest
;
16829 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16831 salt_t
*salt
= hash_buf
->salt
;
16833 char *salt_pos
= input_buf
+ 10;
16835 char *hash_pos
= strchr (salt_pos
, '$');
16837 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16839 uint salt_len
= hash_pos
- salt_pos
;
16843 uint hash_len
= input_len
- 10 - salt_len
- 1;
16845 // base64 decode salt
16847 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16849 u8 tmp_buf
[100] = { 0 };
16851 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16853 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16855 tmp_buf
[salt_len
] = 0x80;
16857 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16859 salt
->salt_len
= salt_len
;
16861 // base64 decode hash
16863 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16865 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16867 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16869 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16871 uint user_len
= hash_len
- 32;
16873 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16875 user_len
--; // skip the trailing space
16877 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16878 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16879 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16880 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16882 digest
[0] = byte_swap_32 (digest
[0]);
16883 digest
[1] = byte_swap_32 (digest
[1]);
16884 digest
[2] = byte_swap_32 (digest
[2]);
16885 digest
[3] = byte_swap_32 (digest
[3]);
16887 // store username for host only (output hash if cracked)
16889 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16890 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16892 return (PARSER_OK
);
16895 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16897 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16899 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16901 u32
*digest
= (u32
*) hash_buf
->digest
;
16903 salt_t
*salt
= hash_buf
->salt
;
16905 char *iter_pos
= input_buf
+ 10;
16907 u32 iter
= atoi (iter_pos
);
16911 return (PARSER_SALT_ITERATION
);
16914 iter
--; // first iteration is special
16916 salt
->salt_iter
= iter
;
16918 char *base64_pos
= strchr (iter_pos
, '}');
16920 if (base64_pos
== NULL
)
16922 return (PARSER_SIGNATURE_UNMATCHED
);
16927 // base64 decode salt
16929 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16931 u8 tmp_buf
[100] = { 0 };
16933 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16935 if (decoded_len
< 24)
16937 return (PARSER_SALT_LENGTH
);
16942 uint salt_len
= decoded_len
- 20;
16944 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16945 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16947 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16949 salt
->salt_len
= salt_len
;
16953 u32
*digest_ptr
= (u32
*) tmp_buf
;
16955 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16956 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16957 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16958 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16959 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16961 return (PARSER_OK
);
16964 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16966 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16968 u32
*digest
= (u32
*) hash_buf
->digest
;
16970 salt_t
*salt
= hash_buf
->salt
;
16972 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16973 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16974 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16975 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16976 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16978 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16980 uint salt_len
= input_len
- 40 - 1;
16982 char *salt_buf
= input_buf
+ 40 + 1;
16984 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16986 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16988 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16990 salt
->salt_len
= salt_len
;
16992 return (PARSER_OK
);
16995 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16997 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16999 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17001 u32
*digest
= (u32
*) hash_buf
->digest
;
17003 salt_t
*salt
= hash_buf
->salt
;
17005 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17011 char *V_pos
= input_buf
+ 5;
17013 char *R_pos
= strchr (V_pos
, '*');
17015 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17017 u32 V_len
= R_pos
- V_pos
;
17021 char *bits_pos
= strchr (R_pos
, '*');
17023 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17025 u32 R_len
= bits_pos
- R_pos
;
17029 char *P_pos
= strchr (bits_pos
, '*');
17031 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17033 u32 bits_len
= P_pos
- bits_pos
;
17037 char *enc_md_pos
= strchr (P_pos
, '*');
17039 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17041 u32 P_len
= enc_md_pos
- P_pos
;
17045 char *id_len_pos
= strchr (enc_md_pos
, '*');
17047 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17049 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17053 char *id_buf_pos
= strchr (id_len_pos
, '*');
17055 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17057 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17061 char *u_len_pos
= strchr (id_buf_pos
, '*');
17063 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17065 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17067 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17071 char *u_buf_pos
= strchr (u_len_pos
, '*');
17073 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17075 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17079 char *o_len_pos
= strchr (u_buf_pos
, '*');
17081 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17083 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17085 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17089 char *o_buf_pos
= strchr (o_len_pos
, '*');
17091 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17093 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17097 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;
17099 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17103 const int V
= atoi (V_pos
);
17104 const int R
= atoi (R_pos
);
17105 const int P
= atoi (P_pos
);
17107 if (V
!= 1) return (PARSER_SALT_VALUE
);
17108 if (R
!= 2) return (PARSER_SALT_VALUE
);
17110 const int enc_md
= atoi (enc_md_pos
);
17112 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17114 const int id_len
= atoi (id_len_pos
);
17115 const int u_len
= atoi (u_len_pos
);
17116 const int o_len
= atoi (o_len_pos
);
17118 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17119 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17120 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17122 const int bits
= atoi (bits_pos
);
17124 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17126 // copy data to esalt
17132 pdf
->enc_md
= enc_md
;
17134 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17135 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17136 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17137 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17138 pdf
->id_len
= id_len
;
17140 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17141 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17142 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17143 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17144 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17145 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17146 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17147 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17148 pdf
->u_len
= u_len
;
17150 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17151 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17152 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17153 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17154 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17155 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17156 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17157 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17158 pdf
->o_len
= o_len
;
17160 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17161 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17162 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17163 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17165 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17166 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17167 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17168 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17169 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17170 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17171 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17172 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17174 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17175 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17176 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17177 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17178 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17179 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17180 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17181 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17183 // we use ID for salt, maybe needs to change, we will see...
17185 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17186 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17187 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17188 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17189 salt
->salt_len
= pdf
->id_len
;
17191 digest
[0] = pdf
->u_buf
[0];
17192 digest
[1] = pdf
->u_buf
[1];
17193 digest
[2] = pdf
->u_buf
[2];
17194 digest
[3] = pdf
->u_buf
[3];
17196 return (PARSER_OK
);
17199 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17201 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17204 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17206 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17208 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17210 u32
*digest
= (u32
*) hash_buf
->digest
;
17212 salt_t
*salt
= hash_buf
->salt
;
17214 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17220 char *V_pos
= input_buf
+ 5;
17222 char *R_pos
= strchr (V_pos
, '*');
17224 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17226 u32 V_len
= R_pos
- V_pos
;
17230 char *bits_pos
= strchr (R_pos
, '*');
17232 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17234 u32 R_len
= bits_pos
- R_pos
;
17238 char *P_pos
= strchr (bits_pos
, '*');
17240 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17242 u32 bits_len
= P_pos
- bits_pos
;
17246 char *enc_md_pos
= strchr (P_pos
, '*');
17248 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17250 u32 P_len
= enc_md_pos
- P_pos
;
17254 char *id_len_pos
= strchr (enc_md_pos
, '*');
17256 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17258 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17262 char *id_buf_pos
= strchr (id_len_pos
, '*');
17264 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17266 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17270 char *u_len_pos
= strchr (id_buf_pos
, '*');
17272 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17274 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17276 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17280 char *u_buf_pos
= strchr (u_len_pos
, '*');
17282 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17288 char *o_len_pos
= strchr (u_buf_pos
, '*');
17290 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17294 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17298 char *o_buf_pos
= strchr (o_len_pos
, '*');
17300 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17306 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17308 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17312 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17316 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;
17318 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17322 const int V
= atoi (V_pos
);
17323 const int R
= atoi (R_pos
);
17324 const int P
= atoi (P_pos
);
17326 if (V
!= 1) return (PARSER_SALT_VALUE
);
17327 if (R
!= 2) return (PARSER_SALT_VALUE
);
17329 const int enc_md
= atoi (enc_md_pos
);
17331 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17333 const int id_len
= atoi (id_len_pos
);
17334 const int u_len
= atoi (u_len_pos
);
17335 const int o_len
= atoi (o_len_pos
);
17337 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17338 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17339 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17341 const int bits
= atoi (bits_pos
);
17343 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17345 // copy data to esalt
17351 pdf
->enc_md
= enc_md
;
17353 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17354 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17355 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17356 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17357 pdf
->id_len
= id_len
;
17359 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17360 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17361 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17362 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17363 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17364 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17365 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17366 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17367 pdf
->u_len
= u_len
;
17369 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17370 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17371 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17372 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17373 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17374 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17375 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17376 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17377 pdf
->o_len
= o_len
;
17379 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17380 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17381 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17382 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17384 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17385 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17386 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17387 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17388 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17389 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17390 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17391 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17393 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17394 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17395 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17396 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17397 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17398 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17399 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17400 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17402 pdf
->rc4key
[1] = 0;
17403 pdf
->rc4key
[0] = 0;
17405 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17406 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17407 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17408 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17409 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17410 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17411 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17412 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17413 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17414 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17416 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17417 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17419 // we use ID for salt, maybe needs to change, we will see...
17421 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17422 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17423 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17424 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17425 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17426 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17427 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17428 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17429 salt
->salt_len
= pdf
->id_len
+ 16;
17431 digest
[0] = pdf
->rc4key
[0];
17432 digest
[1] = pdf
->rc4key
[1];
17436 return (PARSER_OK
);
17439 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17441 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17443 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17445 u32
*digest
= (u32
*) hash_buf
->digest
;
17447 salt_t
*salt
= hash_buf
->salt
;
17449 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17455 char *V_pos
= input_buf
+ 5;
17457 char *R_pos
= strchr (V_pos
, '*');
17459 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17461 u32 V_len
= R_pos
- V_pos
;
17465 char *bits_pos
= strchr (R_pos
, '*');
17467 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17469 u32 R_len
= bits_pos
- R_pos
;
17473 char *P_pos
= strchr (bits_pos
, '*');
17475 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17477 u32 bits_len
= P_pos
- bits_pos
;
17481 char *enc_md_pos
= strchr (P_pos
, '*');
17483 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17485 u32 P_len
= enc_md_pos
- P_pos
;
17489 char *id_len_pos
= strchr (enc_md_pos
, '*');
17491 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17493 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17497 char *id_buf_pos
= strchr (id_len_pos
, '*');
17499 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17501 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17505 char *u_len_pos
= strchr (id_buf_pos
, '*');
17507 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17509 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17511 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17515 char *u_buf_pos
= strchr (u_len_pos
, '*');
17517 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17519 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17523 char *o_len_pos
= strchr (u_buf_pos
, '*');
17525 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17527 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17529 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17533 char *o_buf_pos
= strchr (o_len_pos
, '*');
17535 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17537 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17541 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;
17543 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17547 const int V
= atoi (V_pos
);
17548 const int R
= atoi (R_pos
);
17549 const int P
= atoi (P_pos
);
17553 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17554 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17556 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17558 const int id_len
= atoi (id_len_pos
);
17559 const int u_len
= atoi (u_len_pos
);
17560 const int o_len
= atoi (o_len_pos
);
17562 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17564 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17565 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17567 const int bits
= atoi (bits_pos
);
17569 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17575 enc_md
= atoi (enc_md_pos
);
17578 // copy data to esalt
17584 pdf
->enc_md
= enc_md
;
17586 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17587 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17588 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17589 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17593 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17594 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17595 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17596 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17599 pdf
->id_len
= id_len
;
17601 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17602 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17603 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17604 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17605 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17606 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17607 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17608 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17609 pdf
->u_len
= u_len
;
17611 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17612 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17613 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17614 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17615 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17616 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17617 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17618 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17619 pdf
->o_len
= o_len
;
17621 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17622 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17623 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17624 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17628 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17629 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17630 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17631 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17634 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17635 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17636 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17637 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17638 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17639 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17640 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17641 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17643 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17644 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17645 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17646 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17647 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17648 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17649 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17650 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17652 // precompute rc4 data for later use
17668 uint salt_pc_block
[32] = { 0 };
17670 char *salt_pc_ptr
= (char *) salt_pc_block
;
17672 memcpy (salt_pc_ptr
, padding
, 32);
17673 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17675 uint salt_pc_digest
[4] = { 0 };
17677 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17679 pdf
->rc4data
[0] = salt_pc_digest
[0];
17680 pdf
->rc4data
[1] = salt_pc_digest
[1];
17682 // we use ID for salt, maybe needs to change, we will see...
17684 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17685 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17686 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17687 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17688 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17689 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17690 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17691 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17692 salt
->salt_len
= pdf
->id_len
+ 16;
17694 salt
->salt_iter
= ROUNDS_PDF14
;
17696 digest
[0] = pdf
->u_buf
[0];
17697 digest
[1] = pdf
->u_buf
[1];
17701 return (PARSER_OK
);
17704 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17706 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17708 if (ret
!= PARSER_OK
)
17713 u32
*digest
= (u32
*) hash_buf
->digest
;
17715 salt_t
*salt
= hash_buf
->salt
;
17717 digest
[0] -= SHA256M_A
;
17718 digest
[1] -= SHA256M_B
;
17719 digest
[2] -= SHA256M_C
;
17720 digest
[3] -= SHA256M_D
;
17721 digest
[4] -= SHA256M_E
;
17722 digest
[5] -= SHA256M_F
;
17723 digest
[6] -= SHA256M_G
;
17724 digest
[7] -= SHA256M_H
;
17726 salt
->salt_buf
[2] = 0x80;
17728 return (PARSER_OK
);
17731 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17733 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17735 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17737 u32
*digest
= (u32
*) hash_buf
->digest
;
17739 salt_t
*salt
= hash_buf
->salt
;
17741 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17747 char *V_pos
= input_buf
+ 5;
17749 char *R_pos
= strchr (V_pos
, '*');
17751 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17753 u32 V_len
= R_pos
- V_pos
;
17757 char *bits_pos
= strchr (R_pos
, '*');
17759 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17761 u32 R_len
= bits_pos
- R_pos
;
17765 char *P_pos
= strchr (bits_pos
, '*');
17767 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17769 u32 bits_len
= P_pos
- bits_pos
;
17773 char *enc_md_pos
= strchr (P_pos
, '*');
17775 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17777 u32 P_len
= enc_md_pos
- P_pos
;
17781 char *id_len_pos
= strchr (enc_md_pos
, '*');
17783 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17785 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17789 char *id_buf_pos
= strchr (id_len_pos
, '*');
17791 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17793 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17797 char *u_len_pos
= strchr (id_buf_pos
, '*');
17799 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17801 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17805 char *u_buf_pos
= strchr (u_len_pos
, '*');
17807 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17809 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17813 char *o_len_pos
= strchr (u_buf_pos
, '*');
17815 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17817 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17821 char *o_buf_pos
= strchr (o_len_pos
, '*');
17823 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17825 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17829 char *last
= strchr (o_buf_pos
, '*');
17831 if (last
== NULL
) last
= input_buf
+ input_len
;
17833 u32 o_buf_len
= last
- o_buf_pos
;
17837 const int V
= atoi (V_pos
);
17838 const int R
= atoi (R_pos
);
17842 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17843 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17845 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17847 const int bits
= atoi (bits_pos
);
17849 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17851 int enc_md
= atoi (enc_md_pos
);
17853 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17855 const uint id_len
= atoi (id_len_pos
);
17856 const uint u_len
= atoi (u_len_pos
);
17857 const uint o_len
= atoi (o_len_pos
);
17859 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17860 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17861 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17862 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17863 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17864 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17865 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17866 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17868 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17869 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17870 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17872 // copy data to esalt
17874 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17876 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17878 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17881 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17882 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17884 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17885 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17887 salt
->salt_len
= 8;
17888 salt
->salt_iter
= ROUNDS_PDF17L8
;
17890 digest
[0] = pdf
->u_buf
[0];
17891 digest
[1] = pdf
->u_buf
[1];
17892 digest
[2] = pdf
->u_buf
[2];
17893 digest
[3] = pdf
->u_buf
[3];
17894 digest
[4] = pdf
->u_buf
[4];
17895 digest
[5] = pdf
->u_buf
[5];
17896 digest
[6] = pdf
->u_buf
[6];
17897 digest
[7] = pdf
->u_buf
[7];
17899 return (PARSER_OK
);
17902 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17904 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17906 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17908 u32
*digest
= (u32
*) hash_buf
->digest
;
17910 salt_t
*salt
= hash_buf
->salt
;
17912 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17920 char *iter_pos
= input_buf
+ 7;
17922 u32 iter
= atoi (iter_pos
);
17924 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17925 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17927 // first is *raw* salt
17929 char *salt_pos
= strchr (iter_pos
, ':');
17931 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17935 char *hash_pos
= strchr (salt_pos
, ':');
17937 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17939 u32 salt_len
= hash_pos
- salt_pos
;
17941 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17945 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17947 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17951 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17953 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17955 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17957 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17958 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17960 salt
->salt_len
= salt_len
;
17961 salt
->salt_iter
= iter
- 1;
17965 u8 tmp_buf
[100] = { 0 };
17967 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17969 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17971 memcpy (digest
, tmp_buf
, 16);
17973 digest
[0] = byte_swap_32 (digest
[0]);
17974 digest
[1] = byte_swap_32 (digest
[1]);
17975 digest
[2] = byte_swap_32 (digest
[2]);
17976 digest
[3] = byte_swap_32 (digest
[3]);
17978 // add some stuff to normal salt to make sorted happy
17980 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17981 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17982 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17983 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17984 salt
->salt_buf
[4] = salt
->salt_iter
;
17986 return (PARSER_OK
);
17989 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17991 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17993 u32
*digest
= (u32
*) hash_buf
->digest
;
17995 salt_t
*salt
= hash_buf
->salt
;
17997 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17998 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17999 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18000 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18002 digest
[0] = byte_swap_32 (digest
[0]);
18003 digest
[1] = byte_swap_32 (digest
[1]);
18004 digest
[2] = byte_swap_32 (digest
[2]);
18005 digest
[3] = byte_swap_32 (digest
[3]);
18007 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18009 uint salt_len
= input_len
- 32 - 1;
18011 char *salt_buf
= input_buf
+ 32 + 1;
18013 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18015 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18017 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18019 salt
->salt_len
= salt_len
;
18021 return (PARSER_OK
);
18024 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18026 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18028 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18030 u32
*digest
= (u32
*) hash_buf
->digest
;
18032 salt_t
*salt
= hash_buf
->salt
;
18034 char *user_pos
= input_buf
+ 10;
18036 char *salt_pos
= strchr (user_pos
, '*');
18038 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18042 char *hash_pos
= strchr (salt_pos
, '*');
18046 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18048 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18050 uint user_len
= salt_pos
- user_pos
- 1;
18052 uint salt_len
= hash_pos
- salt_pos
- 1;
18054 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18060 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18061 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18062 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18063 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18065 digest
[0] = byte_swap_32 (digest
[0]);
18066 digest
[1] = byte_swap_32 (digest
[1]);
18067 digest
[2] = byte_swap_32 (digest
[2]);
18068 digest
[3] = byte_swap_32 (digest
[3]);
18070 digest
[0] -= MD5M_A
;
18071 digest
[1] -= MD5M_B
;
18072 digest
[2] -= MD5M_C
;
18073 digest
[3] -= MD5M_D
;
18079 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18081 // first 4 bytes are the "challenge"
18083 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18084 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18085 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18086 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18088 // append the user name
18090 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18092 salt
->salt_len
= 4 + user_len
;
18094 return (PARSER_OK
);
18097 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18099 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18101 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18103 u32
*digest
= (u32
*) hash_buf
->digest
;
18105 salt_t
*salt
= hash_buf
->salt
;
18107 char *salt_pos
= input_buf
+ 9;
18109 char *hash_pos
= strchr (salt_pos
, '*');
18111 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18115 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18117 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18119 uint salt_len
= hash_pos
- salt_pos
- 1;
18121 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18127 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18128 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18129 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18130 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18131 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18141 salt
->salt_len
= salt_len
;
18143 return (PARSER_OK
);
18146 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18148 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18150 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18152 u32
*digest
= (u32
*) hash_buf
->digest
;
18154 salt_t
*salt
= hash_buf
->salt
;
18156 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18162 char *cry_master_len_pos
= input_buf
+ 9;
18164 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18166 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18168 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18170 cry_master_buf_pos
++;
18172 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18174 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18176 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18178 cry_salt_len_pos
++;
18180 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18182 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18184 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18186 cry_salt_buf_pos
++;
18188 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18190 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18192 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18196 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18198 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18200 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18204 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18206 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18208 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18212 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18214 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18216 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18218 public_key_len_pos
++;
18220 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18222 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18224 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18226 public_key_buf_pos
++;
18228 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;
18230 const uint cry_master_len
= atoi (cry_master_len_pos
);
18231 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18232 const uint ckey_len
= atoi (ckey_len_pos
);
18233 const uint public_key_len
= atoi (public_key_len_pos
);
18235 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18236 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18237 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18238 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18240 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18242 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18244 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18247 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18249 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18251 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18254 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18256 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18258 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18261 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18262 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18263 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18266 * store digest (should be unique enought, hopefully)
18269 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18270 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18271 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18272 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18278 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18280 const uint cry_rounds
= atoi (cry_rounds_pos
);
18282 salt
->salt_iter
= cry_rounds
- 1;
18284 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18286 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18288 salt
->salt_len
= salt_len
;
18290 return (PARSER_OK
);
18293 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18295 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18297 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18299 u32
*digest
= (u32
*) hash_buf
->digest
;
18301 salt_t
*salt
= hash_buf
->salt
;
18303 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18305 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18307 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18309 memcpy (temp_input_buf
, input_buf
, input_len
);
18313 char *URI_server_pos
= temp_input_buf
+ 6;
18315 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18317 if (URI_client_pos
== NULL
)
18319 myfree (temp_input_buf
);
18321 return (PARSER_SEPARATOR_UNMATCHED
);
18324 URI_client_pos
[0] = 0;
18327 uint URI_server_len
= strlen (URI_server_pos
);
18329 if (URI_server_len
> 512)
18331 myfree (temp_input_buf
);
18333 return (PARSER_SALT_LENGTH
);
18338 char *user_pos
= strchr (URI_client_pos
, '*');
18340 if (user_pos
== NULL
)
18342 myfree (temp_input_buf
);
18344 return (PARSER_SEPARATOR_UNMATCHED
);
18350 uint URI_client_len
= strlen (URI_client_pos
);
18352 if (URI_client_len
> 512)
18354 myfree (temp_input_buf
);
18356 return (PARSER_SALT_LENGTH
);
18361 char *realm_pos
= strchr (user_pos
, '*');
18363 if (realm_pos
== NULL
)
18365 myfree (temp_input_buf
);
18367 return (PARSER_SEPARATOR_UNMATCHED
);
18373 uint user_len
= strlen (user_pos
);
18375 if (user_len
> 116)
18377 myfree (temp_input_buf
);
18379 return (PARSER_SALT_LENGTH
);
18384 char *method_pos
= strchr (realm_pos
, '*');
18386 if (method_pos
== NULL
)
18388 myfree (temp_input_buf
);
18390 return (PARSER_SEPARATOR_UNMATCHED
);
18396 uint realm_len
= strlen (realm_pos
);
18398 if (realm_len
> 116)
18400 myfree (temp_input_buf
);
18402 return (PARSER_SALT_LENGTH
);
18407 char *URI_prefix_pos
= strchr (method_pos
, '*');
18409 if (URI_prefix_pos
== NULL
)
18411 myfree (temp_input_buf
);
18413 return (PARSER_SEPARATOR_UNMATCHED
);
18416 URI_prefix_pos
[0] = 0;
18419 uint method_len
= strlen (method_pos
);
18421 if (method_len
> 246)
18423 myfree (temp_input_buf
);
18425 return (PARSER_SALT_LENGTH
);
18430 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18432 if (URI_resource_pos
== NULL
)
18434 myfree (temp_input_buf
);
18436 return (PARSER_SEPARATOR_UNMATCHED
);
18439 URI_resource_pos
[0] = 0;
18440 URI_resource_pos
++;
18442 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18444 if (URI_prefix_len
> 245)
18446 myfree (temp_input_buf
);
18448 return (PARSER_SALT_LENGTH
);
18453 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18455 if (URI_suffix_pos
== NULL
)
18457 myfree (temp_input_buf
);
18459 return (PARSER_SEPARATOR_UNMATCHED
);
18462 URI_suffix_pos
[0] = 0;
18465 uint URI_resource_len
= strlen (URI_resource_pos
);
18467 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18469 myfree (temp_input_buf
);
18471 return (PARSER_SALT_LENGTH
);
18476 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18478 if (nonce_pos
== NULL
)
18480 myfree (temp_input_buf
);
18482 return (PARSER_SEPARATOR_UNMATCHED
);
18488 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18490 if (URI_suffix_len
> 245)
18492 myfree (temp_input_buf
);
18494 return (PARSER_SALT_LENGTH
);
18499 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18501 if (nonce_client_pos
== NULL
)
18503 myfree (temp_input_buf
);
18505 return (PARSER_SEPARATOR_UNMATCHED
);
18508 nonce_client_pos
[0] = 0;
18509 nonce_client_pos
++;
18511 uint nonce_len
= strlen (nonce_pos
);
18513 if (nonce_len
< 1 || nonce_len
> 50)
18515 myfree (temp_input_buf
);
18517 return (PARSER_SALT_LENGTH
);
18522 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18524 if (nonce_count_pos
== NULL
)
18526 myfree (temp_input_buf
);
18528 return (PARSER_SEPARATOR_UNMATCHED
);
18531 nonce_count_pos
[0] = 0;
18534 uint nonce_client_len
= strlen (nonce_client_pos
);
18536 if (nonce_client_len
> 50)
18538 myfree (temp_input_buf
);
18540 return (PARSER_SALT_LENGTH
);
18545 char *qop_pos
= strchr (nonce_count_pos
, '*');
18547 if (qop_pos
== NULL
)
18549 myfree (temp_input_buf
);
18551 return (PARSER_SEPARATOR_UNMATCHED
);
18557 uint nonce_count_len
= strlen (nonce_count_pos
);
18559 if (nonce_count_len
> 50)
18561 myfree (temp_input_buf
);
18563 return (PARSER_SALT_LENGTH
);
18568 char *directive_pos
= strchr (qop_pos
, '*');
18570 if (directive_pos
== NULL
)
18572 myfree (temp_input_buf
);
18574 return (PARSER_SEPARATOR_UNMATCHED
);
18577 directive_pos
[0] = 0;
18580 uint qop_len
= strlen (qop_pos
);
18584 myfree (temp_input_buf
);
18586 return (PARSER_SALT_LENGTH
);
18591 char *digest_pos
= strchr (directive_pos
, '*');
18593 if (digest_pos
== NULL
)
18595 myfree (temp_input_buf
);
18597 return (PARSER_SEPARATOR_UNMATCHED
);
18603 uint directive_len
= strlen (directive_pos
);
18605 if (directive_len
!= 3)
18607 myfree (temp_input_buf
);
18609 return (PARSER_SALT_LENGTH
);
18612 if (memcmp (directive_pos
, "MD5", 3))
18614 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18616 myfree (temp_input_buf
);
18618 return (PARSER_SIP_AUTH_DIRECTIVE
);
18622 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18627 uint md5_max_len
= 4 * 64;
18629 uint md5_remaining_len
= md5_max_len
;
18631 uint tmp_md5_buf
[64] = { 0 };
18633 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18635 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18637 md5_len
+= method_len
+ 1;
18638 tmp_md5_ptr
+= method_len
+ 1;
18640 if (URI_prefix_len
> 0)
18642 md5_remaining_len
= md5_max_len
- md5_len
;
18644 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18646 md5_len
+= URI_prefix_len
+ 1;
18647 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18650 md5_remaining_len
= md5_max_len
- md5_len
;
18652 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18654 md5_len
+= URI_resource_len
;
18655 tmp_md5_ptr
+= URI_resource_len
;
18657 if (URI_suffix_len
> 0)
18659 md5_remaining_len
= md5_max_len
- md5_len
;
18661 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18663 md5_len
+= 1 + URI_suffix_len
;
18666 uint tmp_digest
[4] = { 0 };
18668 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18670 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18671 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18672 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18673 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18679 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18681 uint esalt_len
= 0;
18683 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18685 // there are 2 possibilities for the esalt:
18687 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18689 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_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:%s:%s:%s:%08x%08x%08x%08x",
18710 esalt_len
= 1 + nonce_len
+ 1 + 32;
18712 if (esalt_len
> max_esalt_len
)
18714 myfree (temp_input_buf
);
18716 return (PARSER_SALT_LENGTH
);
18719 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18727 // add 0x80 to esalt
18729 esalt_buf_ptr
[esalt_len
] = 0x80;
18731 sip
->esalt_len
= esalt_len
;
18737 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18739 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18741 uint max_salt_len
= 119;
18743 if (salt_len
> max_salt_len
)
18745 myfree (temp_input_buf
);
18747 return (PARSER_SALT_LENGTH
);
18750 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18752 sip
->salt_len
= salt_len
;
18755 * fake salt (for sorting)
18758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18762 uint fake_salt_len
= salt_len
;
18764 if (fake_salt_len
> max_salt_len
)
18766 fake_salt_len
= max_salt_len
;
18769 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18771 salt
->salt_len
= fake_salt_len
;
18777 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18778 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18779 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18780 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18782 digest
[0] = byte_swap_32 (digest
[0]);
18783 digest
[1] = byte_swap_32 (digest
[1]);
18784 digest
[2] = byte_swap_32 (digest
[2]);
18785 digest
[3] = byte_swap_32 (digest
[3]);
18787 myfree (temp_input_buf
);
18789 return (PARSER_OK
);
18792 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18794 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18796 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18798 u32
*digest
= (u32
*) hash_buf
->digest
;
18800 salt_t
*salt
= hash_buf
->salt
;
18804 char *digest_pos
= input_buf
;
18806 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18813 char *salt_buf
= input_buf
+ 8 + 1;
18817 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18819 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18821 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18823 salt
->salt_len
= salt_len
;
18825 return (PARSER_OK
);
18828 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18830 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18832 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18834 u32
*digest
= (u32
*) hash_buf
->digest
;
18836 salt_t
*salt
= hash_buf
->salt
;
18838 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18844 char *p_buf_pos
= input_buf
+ 4;
18846 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18848 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18850 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18852 NumCyclesPower_pos
++;
18854 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18856 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18858 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18862 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18864 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18866 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18870 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18872 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18874 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18878 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18880 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18882 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18886 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18888 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18890 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18894 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18896 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18898 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18902 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18904 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18906 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18910 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18912 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18914 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18918 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;
18920 const uint iter
= atoi (NumCyclesPower_pos
);
18921 const uint crc
= atoi (crc_buf_pos
);
18922 const uint p_buf
= atoi (p_buf_pos
);
18923 const uint salt_len
= atoi (salt_len_pos
);
18924 const uint iv_len
= atoi (iv_len_pos
);
18925 const uint unpack_size
= atoi (unpack_size_pos
);
18926 const uint data_len
= atoi (data_len_pos
);
18932 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18933 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18935 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18937 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18939 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18945 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18946 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18947 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18948 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18950 seven_zip
->iv_len
= iv_len
;
18952 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18954 seven_zip
->salt_len
= 0;
18956 seven_zip
->crc
= crc
;
18958 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18960 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18962 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18965 seven_zip
->data_len
= data_len
;
18967 seven_zip
->unpack_size
= unpack_size
;
18971 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18972 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18973 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18974 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18976 salt
->salt_len
= 16;
18978 salt
->salt_sign
[0] = iter
;
18980 salt
->salt_iter
= 1 << iter
;
18991 return (PARSER_OK
);
18994 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18996 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18998 u32
*digest
= (u32
*) hash_buf
->digest
;
19000 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19001 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19002 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19003 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19004 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19005 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19006 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19007 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19009 digest
[0] = byte_swap_32 (digest
[0]);
19010 digest
[1] = byte_swap_32 (digest
[1]);
19011 digest
[2] = byte_swap_32 (digest
[2]);
19012 digest
[3] = byte_swap_32 (digest
[3]);
19013 digest
[4] = byte_swap_32 (digest
[4]);
19014 digest
[5] = byte_swap_32 (digest
[5]);
19015 digest
[6] = byte_swap_32 (digest
[6]);
19016 digest
[7] = byte_swap_32 (digest
[7]);
19018 return (PARSER_OK
);
19021 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19023 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19025 u32
*digest
= (u32
*) hash_buf
->digest
;
19027 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19028 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19029 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19030 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19031 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19032 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19033 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19034 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19035 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19036 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19037 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19038 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19039 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19040 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19041 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19042 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19044 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19045 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19046 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19047 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19048 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19049 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19050 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19051 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19052 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19053 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19054 digest
[10] = byte_swap_32 (digest
[10]);
19055 digest
[11] = byte_swap_32 (digest
[11]);
19056 digest
[12] = byte_swap_32 (digest
[12]);
19057 digest
[13] = byte_swap_32 (digest
[13]);
19058 digest
[14] = byte_swap_32 (digest
[14]);
19059 digest
[15] = byte_swap_32 (digest
[15]);
19061 return (PARSER_OK
);
19064 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19066 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19068 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19070 u32
*digest
= (u32
*) hash_buf
->digest
;
19072 salt_t
*salt
= hash_buf
->salt
;
19074 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19082 char *iter_pos
= input_buf
+ 4;
19084 u32 iter
= atoi (iter_pos
);
19086 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19087 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19089 // first is *raw* salt
19091 char *salt_pos
= strchr (iter_pos
, ':');
19093 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19097 char *hash_pos
= strchr (salt_pos
, ':');
19099 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19101 u32 salt_len
= hash_pos
- salt_pos
;
19103 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19107 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19109 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19113 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19115 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19117 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19119 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19120 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19122 salt
->salt_len
= salt_len
;
19123 salt
->salt_iter
= iter
- 1;
19127 u8 tmp_buf
[100] = { 0 };
19129 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19131 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19133 memcpy (digest
, tmp_buf
, 16);
19135 // add some stuff to normal salt to make sorted happy
19137 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19138 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19139 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19140 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19141 salt
->salt_buf
[4] = salt
->salt_iter
;
19143 return (PARSER_OK
);
19146 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19148 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19150 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19152 u32
*digest
= (u32
*) hash_buf
->digest
;
19154 salt_t
*salt
= hash_buf
->salt
;
19156 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19164 char *iter_pos
= input_buf
+ 5;
19166 u32 iter
= atoi (iter_pos
);
19168 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19169 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19171 // first is *raw* salt
19173 char *salt_pos
= strchr (iter_pos
, ':');
19175 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19179 char *hash_pos
= strchr (salt_pos
, ':');
19181 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19183 u32 salt_len
= hash_pos
- salt_pos
;
19185 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19189 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19191 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19195 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19201 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19202 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19204 salt
->salt_len
= salt_len
;
19205 salt
->salt_iter
= iter
- 1;
19209 u8 tmp_buf
[100] = { 0 };
19211 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19213 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19215 memcpy (digest
, tmp_buf
, 16);
19217 digest
[0] = byte_swap_32 (digest
[0]);
19218 digest
[1] = byte_swap_32 (digest
[1]);
19219 digest
[2] = byte_swap_32 (digest
[2]);
19220 digest
[3] = byte_swap_32 (digest
[3]);
19222 // add some stuff to normal salt to make sorted happy
19224 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19225 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19226 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19227 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19228 salt
->salt_buf
[4] = salt
->salt_iter
;
19230 return (PARSER_OK
);
19233 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19235 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19237 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19239 u64
*digest
= (u64
*) hash_buf
->digest
;
19241 salt_t
*salt
= hash_buf
->salt
;
19243 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19251 char *iter_pos
= input_buf
+ 7;
19253 u32 iter
= atoi (iter_pos
);
19255 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19256 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19258 // first is *raw* salt
19260 char *salt_pos
= strchr (iter_pos
, ':');
19262 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19266 char *hash_pos
= strchr (salt_pos
, ':');
19268 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19270 u32 salt_len
= hash_pos
- salt_pos
;
19272 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19276 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19278 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19282 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19284 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19286 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19288 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19289 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19291 salt
->salt_len
= salt_len
;
19292 salt
->salt_iter
= iter
- 1;
19296 u8 tmp_buf
[100] = { 0 };
19298 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19300 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19302 memcpy (digest
, tmp_buf
, 64);
19304 digest
[0] = byte_swap_64 (digest
[0]);
19305 digest
[1] = byte_swap_64 (digest
[1]);
19306 digest
[2] = byte_swap_64 (digest
[2]);
19307 digest
[3] = byte_swap_64 (digest
[3]);
19308 digest
[4] = byte_swap_64 (digest
[4]);
19309 digest
[5] = byte_swap_64 (digest
[5]);
19310 digest
[6] = byte_swap_64 (digest
[6]);
19311 digest
[7] = byte_swap_64 (digest
[7]);
19313 // add some stuff to normal salt to make sorted happy
19315 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19316 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19317 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19318 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19319 salt
->salt_buf
[4] = salt
->salt_iter
;
19321 return (PARSER_OK
);
19324 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19326 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19328 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19330 uint
*digest
= (uint
*) hash_buf
->digest
;
19332 salt_t
*salt
= hash_buf
->salt
;
19338 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19340 char *hash_pos
= strchr (salt_pos
, '$');
19342 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19344 u32 salt_len
= hash_pos
- salt_pos
;
19346 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19350 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19352 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19356 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19357 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19375 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19376 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19378 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19379 salt
->salt_len
= 8;
19381 return (PARSER_OK
);
19384 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19386 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19388 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19390 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19392 if (c19
& 3) return (PARSER_HASH_VALUE
);
19394 salt_t
*salt
= hash_buf
->salt
;
19396 u32
*digest
= (u32
*) hash_buf
->digest
;
19400 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19401 | itoa64_to_int (input_buf
[2]) << 6
19402 | itoa64_to_int (input_buf
[3]) << 12
19403 | itoa64_to_int (input_buf
[4]) << 18;
19407 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19408 | itoa64_to_int (input_buf
[6]) << 6
19409 | itoa64_to_int (input_buf
[7]) << 12
19410 | itoa64_to_int (input_buf
[8]) << 18;
19412 salt
->salt_len
= 4;
19414 u8 tmp_buf
[100] = { 0 };
19416 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19418 memcpy (digest
, tmp_buf
, 8);
19422 IP (digest
[0], digest
[1], tt
);
19424 digest
[0] = rotr32 (digest
[0], 31);
19425 digest
[1] = rotr32 (digest
[1], 31);
19429 return (PARSER_OK
);
19432 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19434 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19436 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19438 u32
*digest
= (u32
*) hash_buf
->digest
;
19440 salt_t
*salt
= hash_buf
->salt
;
19446 char *type_pos
= input_buf
+ 6 + 1;
19448 char *salt_pos
= strchr (type_pos
, '*');
19450 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19452 u32 type_len
= salt_pos
- type_pos
;
19454 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19458 char *crypted_pos
= strchr (salt_pos
, '*');
19460 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19462 u32 salt_len
= crypted_pos
- salt_pos
;
19464 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19468 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19470 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19476 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19477 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19479 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19480 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19482 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19483 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19484 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19485 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19487 salt
->salt_len
= 24;
19488 salt
->salt_iter
= ROUNDS_RAR3
;
19490 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19491 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19493 digest
[0] = 0xc43d7b00;
19494 digest
[1] = 0x40070000;
19498 return (PARSER_OK
);
19501 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19503 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19505 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19507 u32
*digest
= (u32
*) hash_buf
->digest
;
19509 salt_t
*salt
= hash_buf
->salt
;
19511 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19517 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19519 char *param1_pos
= strchr (param0_pos
, '$');
19521 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19523 u32 param0_len
= param1_pos
- param0_pos
;
19527 char *param2_pos
= strchr (param1_pos
, '$');
19529 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19531 u32 param1_len
= param2_pos
- param1_pos
;
19535 char *param3_pos
= strchr (param2_pos
, '$');
19537 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19539 u32 param2_len
= param3_pos
- param2_pos
;
19543 char *param4_pos
= strchr (param3_pos
, '$');
19545 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19547 u32 param3_len
= param4_pos
- param3_pos
;
19551 char *param5_pos
= strchr (param4_pos
, '$');
19553 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19555 u32 param4_len
= param5_pos
- param4_pos
;
19559 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19561 char *salt_buf
= param1_pos
;
19562 char *iv
= param3_pos
;
19563 char *pswcheck
= param5_pos
;
19565 const uint salt_len
= atoi (param0_pos
);
19566 const uint iterations
= atoi (param2_pos
);
19567 const uint pswcheck_len
= atoi (param4_pos
);
19573 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19574 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19575 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19577 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19578 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19579 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19585 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19586 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19587 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19588 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19590 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19591 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19592 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19593 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19595 salt
->salt_len
= 16;
19597 salt
->salt_sign
[0] = iterations
;
19599 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19605 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19606 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19610 return (PARSER_OK
);
19613 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19615 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19617 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19619 u32
*digest
= (u32
*) hash_buf
->digest
;
19621 salt_t
*salt
= hash_buf
->salt
;
19623 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19630 char *account_pos
= input_buf
+ 11 + 1;
19636 if (account_pos
[0] == '*')
19640 data_pos
= strchr (account_pos
, '*');
19645 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19647 uint account_len
= data_pos
- account_pos
+ 1;
19649 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19654 data_len
= input_len
- 11 - 1 - account_len
- 2;
19656 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19660 /* assume $krb5tgs$23$checksum$edata2 */
19661 data_pos
= account_pos
;
19663 memcpy (krb5tgs
->account_info
, "**", 3);
19665 data_len
= input_len
- 11 - 1 - 1;
19668 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19670 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19672 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19674 const char p0
= data_pos
[i
+ 0];
19675 const char p1
= data_pos
[i
+ 1];
19677 *checksum_ptr
++ = hex_convert (p1
) << 0
19678 | hex_convert (p0
) << 4;
19681 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19683 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19686 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19688 const char p0
= data_pos
[i
+ 0];
19689 const char p1
= data_pos
[i
+ 1];
19690 *edata_ptr
++ = hex_convert (p1
) << 0
19691 | hex_convert (p0
) << 4;
19694 /* this is needed for hmac_md5 */
19695 *edata_ptr
++ = 0x80;
19697 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19698 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19699 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19700 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19702 salt
->salt_len
= 32;
19704 digest
[0] = krb5tgs
->checksum
[0];
19705 digest
[1] = krb5tgs
->checksum
[1];
19706 digest
[2] = krb5tgs
->checksum
[2];
19707 digest
[3] = krb5tgs
->checksum
[3];
19709 return (PARSER_OK
);
19712 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19714 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19716 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19718 u32
*digest
= (u32
*) hash_buf
->digest
;
19720 salt_t
*salt
= hash_buf
->salt
;
19727 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19731 char *wrapped_key_pos
;
19735 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19737 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19739 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19741 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19746 data_pos
= salt_pos
;
19748 wrapped_key_pos
= strchr (salt_pos
, '*');
19750 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19752 uint salt_len
= wrapped_key_pos
- salt_pos
;
19754 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19759 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19761 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19763 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19764 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19765 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19766 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19770 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19771 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19772 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19773 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19774 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19775 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19777 salt
->salt_len
= 40;
19779 digest
[0] = salt
->salt_buf
[0];
19780 digest
[1] = salt
->salt_buf
[1];
19781 digest
[2] = salt
->salt_buf
[2];
19782 digest
[3] = salt
->salt_buf
[3];
19784 return (PARSER_OK
);
19787 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19789 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19791 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19793 u32
*digest
= (u32
*) hash_buf
->digest
;
19795 salt_t
*salt
= hash_buf
->salt
;
19797 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19807 char *algorithm_pos
;
19809 char *final_random_seed_pos
;
19810 u32 final_random_seed_len
;
19812 char *transf_random_seed_pos
;
19813 u32 transf_random_seed_len
;
19818 /* default is no keyfile provided */
19819 char *keyfile_len_pos
;
19820 u32 keyfile_len
= 0;
19821 u32 is_keyfile_present
= 0;
19822 char *keyfile_inline_pos
;
19825 /* specific to version 1 */
19826 char *contents_len_pos
;
19828 char *contents_pos
;
19830 /* specific to version 2 */
19831 char *expected_bytes_pos
;
19832 u32 expected_bytes_len
;
19834 char *contents_hash_pos
;
19835 u32 contents_hash_len
;
19837 version_pos
= input_buf
+ 8 + 1 + 1;
19839 keepass
->version
= atoi (version_pos
);
19841 rounds_pos
= strchr (version_pos
, '*');
19843 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19847 salt
->salt_iter
= (atoi (rounds_pos
));
19849 algorithm_pos
= strchr (rounds_pos
, '*');
19851 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19855 keepass
->algorithm
= atoi (algorithm_pos
);
19857 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19859 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19861 final_random_seed_pos
++;
19863 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19864 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19865 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19866 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19868 if (keepass
->version
== 2)
19870 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19871 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19872 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19873 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19876 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19878 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19880 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19882 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19883 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19885 transf_random_seed_pos
++;
19887 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19888 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19889 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19890 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19891 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19892 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19893 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19894 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19896 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19898 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19900 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19902 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19906 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19907 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19908 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19909 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19911 if (keepass
->version
== 1)
19913 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19915 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19917 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19919 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19921 contents_hash_pos
++;
19923 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19924 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19925 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19926 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19927 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19928 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19929 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19930 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19932 /* get length of contents following */
19933 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19935 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19937 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19939 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19943 u32 inline_flag
= atoi (inline_flag_pos
);
19945 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19947 contents_len_pos
= strchr (inline_flag_pos
, '*');
19949 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19951 contents_len_pos
++;
19953 contents_len
= atoi (contents_len_pos
);
19955 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19957 contents_pos
= strchr (contents_len_pos
, '*');
19959 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19965 keepass
->contents_len
= contents_len
;
19967 contents_len
= contents_len
/ 4;
19969 keyfile_inline_pos
= strchr (contents_pos
, '*');
19971 u32 real_contents_len
;
19973 if (keyfile_inline_pos
== NULL
)
19974 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19977 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19978 keyfile_inline_pos
++;
19979 is_keyfile_present
= 1;
19982 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19984 for (i
= 0; i
< contents_len
; i
++)
19985 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19987 else if (keepass
->version
== 2)
19989 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19991 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19993 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19995 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19997 expected_bytes_pos
++;
19999 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20000 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20001 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20002 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20003 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20004 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20005 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20006 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20008 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20010 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20012 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20014 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20016 contents_hash_pos
++;
20018 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20019 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20020 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20021 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20022 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20023 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20024 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20025 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20027 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20029 if (keyfile_inline_pos
== NULL
)
20030 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20033 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20034 keyfile_inline_pos
++;
20035 is_keyfile_present
= 1;
20037 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20040 if (is_keyfile_present
!= 0)
20042 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20046 keyfile_len
= atoi (keyfile_len_pos
);
20048 keepass
->keyfile_len
= keyfile_len
;
20050 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20052 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20054 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20058 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20060 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20062 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20063 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20064 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20065 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20066 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20067 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20068 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20069 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20072 digest
[0] = keepass
->enc_iv
[0];
20073 digest
[1] = keepass
->enc_iv
[1];
20074 digest
[2] = keepass
->enc_iv
[2];
20075 digest
[3] = keepass
->enc_iv
[3];
20077 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20078 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20079 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20080 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20081 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20082 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20083 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20084 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20086 return (PARSER_OK
);
20089 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20091 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20093 u32
*digest
= (u32
*) hash_buf
->digest
;
20095 salt_t
*salt
= hash_buf
->salt
;
20097 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20098 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20099 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20100 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20101 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20102 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20103 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20104 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20106 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20108 uint salt_len
= input_len
- 64 - 1;
20110 char *salt_buf
= input_buf
+ 64 + 1;
20112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20118 salt
->salt_len
= salt_len
;
20121 * we can precompute the first sha256 transform
20124 uint w
[16] = { 0 };
20126 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20127 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20128 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20129 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20130 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20131 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20132 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20133 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20134 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20135 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20136 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20137 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20138 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20139 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20140 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20141 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20143 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20145 sha256_64 (w
, pc256
);
20147 salt
->salt_buf_pc
[0] = pc256
[0];
20148 salt
->salt_buf_pc
[1] = pc256
[1];
20149 salt
->salt_buf_pc
[2] = pc256
[2];
20150 salt
->salt_buf_pc
[3] = pc256
[3];
20151 salt
->salt_buf_pc
[4] = pc256
[4];
20152 salt
->salt_buf_pc
[5] = pc256
[5];
20153 salt
->salt_buf_pc
[6] = pc256
[6];
20154 salt
->salt_buf_pc
[7] = pc256
[7];
20156 digest
[0] -= pc256
[0];
20157 digest
[1] -= pc256
[1];
20158 digest
[2] -= pc256
[2];
20159 digest
[3] -= pc256
[3];
20160 digest
[4] -= pc256
[4];
20161 digest
[5] -= pc256
[5];
20162 digest
[6] -= pc256
[6];
20163 digest
[7] -= pc256
[7];
20165 return (PARSER_OK
);
20168 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20170 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20172 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20174 u32
*digest
= (u32
*) hash_buf
->digest
;
20176 salt_t
*salt
= hash_buf
->salt
;
20182 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20184 char *data_buf_pos
= strchr (data_len_pos
, '$');
20186 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20188 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20190 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20191 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20195 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20197 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20199 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20201 u32 data_len
= atoi (data_len_pos
);
20203 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20209 char *salt_pos
= data_buf_pos
;
20211 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20212 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20213 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20214 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20216 // this is actually the CT, which is also the hash later (if matched)
20218 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20219 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20220 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20221 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20223 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20225 salt
->salt_iter
= 10 - 1;
20231 digest
[0] = salt
->salt_buf
[4];
20232 digest
[1] = salt
->salt_buf
[5];
20233 digest
[2] = salt
->salt_buf
[6];
20234 digest
[3] = salt
->salt_buf
[7];
20236 return (PARSER_OK
);
20239 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20241 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20243 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20245 u32
*digest
= (u32
*) hash_buf
->digest
;
20247 salt_t
*salt
= hash_buf
->salt
;
20253 char *salt_pos
= input_buf
+ 11 + 1;
20255 char *iter_pos
= strchr (salt_pos
, ',');
20257 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20259 u32 salt_len
= iter_pos
- salt_pos
;
20261 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20265 char *hash_pos
= strchr (iter_pos
, ',');
20267 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20269 u32 iter_len
= hash_pos
- iter_pos
;
20271 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20275 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20277 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20283 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20284 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20285 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20286 salt
->salt_buf
[3] = 0x00018000;
20288 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20289 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20290 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20291 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20293 salt
->salt_len
= salt_len
/ 2;
20295 salt
->salt_iter
= atoi (iter_pos
) - 1;
20301 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20302 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20303 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20304 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20305 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20306 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20307 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20308 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20310 return (PARSER_OK
);
20313 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20315 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20317 u32
*digest
= (u32
*) hash_buf
->digest
;
20319 salt_t
*salt
= hash_buf
->salt
;
20325 char *hash_pos
= input_buf
+ 64;
20326 char *salt1_pos
= input_buf
+ 128;
20327 char *salt2_pos
= input_buf
;
20333 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20334 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20335 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20336 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20338 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20339 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20340 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20341 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20343 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20344 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20345 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20346 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20348 salt
->salt_len
= 48;
20350 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20356 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20357 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20358 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20359 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20360 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20361 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20362 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20363 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20365 return (PARSER_OK
);
20368 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20370 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20372 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20373 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20375 u32
*digest
= (u32
*) hash_buf
->digest
;
20377 salt_t
*salt
= hash_buf
->salt
;
20379 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20385 char *param0_pos
= input_buf
+ 6 + 1;
20387 char *param1_pos
= strchr (param0_pos
, '*');
20389 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20391 u32 param0_len
= param1_pos
- param0_pos
;
20395 char *param2_pos
= strchr (param1_pos
, '*');
20397 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20399 u32 param1_len
= param2_pos
- param1_pos
;
20403 char *param3_pos
= strchr (param2_pos
, '*');
20405 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20407 u32 param2_len
= param3_pos
- param2_pos
;
20411 char *param4_pos
= strchr (param3_pos
, '*');
20413 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20415 u32 param3_len
= param4_pos
- param3_pos
;
20419 char *param5_pos
= strchr (param4_pos
, '*');
20421 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20423 u32 param4_len
= param5_pos
- param4_pos
;
20427 char *param6_pos
= strchr (param5_pos
, '*');
20429 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20431 u32 param5_len
= param6_pos
- param5_pos
;
20435 char *param7_pos
= strchr (param6_pos
, '*');
20437 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20439 u32 param6_len
= param7_pos
- param6_pos
;
20443 char *param8_pos
= strchr (param7_pos
, '*');
20445 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20447 u32 param7_len
= param8_pos
- param7_pos
;
20451 const uint type
= atoi (param0_pos
);
20452 const uint mode
= atoi (param1_pos
);
20453 const uint magic
= atoi (param2_pos
);
20455 char *salt_buf
= param3_pos
;
20457 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20459 const uint compress_length
= atoi (param5_pos
);
20461 char *data_buf
= param6_pos
;
20462 char *auth
= param7_pos
;
20468 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20470 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20472 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20474 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20476 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20478 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20480 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20482 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20484 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20486 if (type
!= 0) return (PARSER_SALT_VALUE
);
20488 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20490 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20492 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20500 zip2
->magic
= magic
;
20504 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20505 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20506 zip2
->salt_buf
[2] = 0;
20507 zip2
->salt_buf
[3] = 0;
20509 zip2
->salt_len
= 8;
20511 else if (mode
== 2)
20513 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20514 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20515 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20516 zip2
->salt_buf
[3] = 0;
20518 zip2
->salt_len
= 12;
20520 else if (mode
== 3)
20522 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20523 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20524 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20525 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20527 zip2
->salt_len
= 16;
20530 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20531 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20532 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20533 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20535 zip2
->verify_bytes
= verify_bytes
;
20537 zip2
->compress_length
= compress_length
;
20539 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20541 for (uint i
= 0; i
< param6_len
; i
+= 2)
20543 const char p0
= data_buf
[i
+ 0];
20544 const char p1
= data_buf
[i
+ 1];
20546 *data_buf_ptr
++ = hex_convert (p1
) << 0
20547 | hex_convert (p0
) << 4;
20552 *data_buf_ptr
= 0x80;
20554 char *auth_ptr
= (char *) zip2
->auth_buf
;
20556 for (uint i
= 0; i
< param7_len
; i
+= 2)
20558 const char p0
= auth
[i
+ 0];
20559 const char p1
= auth
[i
+ 1];
20561 *auth_ptr
++ = hex_convert (p1
) << 0
20562 | hex_convert (p0
) << 4;
20571 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20572 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20573 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20574 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20575 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20576 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20577 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20578 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20580 salt
->salt_len
= 32;
20582 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20585 * digest buf (fake)
20588 digest
[0] = zip2
->auth_buf
[0];
20589 digest
[1] = zip2
->auth_buf
[1];
20590 digest
[2] = zip2
->auth_buf
[2];
20591 digest
[3] = zip2
->auth_buf
[3];
20593 return (PARSER_OK
);
20596 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20598 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20600 u32
*digest
= (u32
*) hash_buf
->digest
;
20602 salt_t
*salt
= hash_buf
->salt
;
20604 win8phone_t
*esalt
= hash_buf
->esalt
;
20606 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20607 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20608 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20609 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20610 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20611 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20612 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20613 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20615 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20617 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20619 u32
*salt_buf
= esalt
->salt_buf
;
20621 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20623 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20626 salt
->salt_buf
[0] = salt_buf
[0];
20627 salt
->salt_buf
[1] = salt_buf
[1];
20628 salt
->salt_buf
[2] = salt_buf
[2];
20629 salt
->salt_buf
[3] = salt_buf
[3];
20630 salt
->salt_buf
[4] = salt_buf
[4];
20631 salt
->salt_buf
[5] = salt_buf
[5];
20632 salt
->salt_buf
[6] = salt_buf
[6];
20633 salt
->salt_buf
[7] = salt_buf
[7];
20635 salt
->salt_len
= 64;
20637 return (PARSER_OK
);
20641 * parallel running threads
20646 BOOL WINAPI
sigHandler_default (DWORD sig
)
20650 case CTRL_CLOSE_EVENT
:
20653 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20654 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20655 * function otherwise it is too late (e.g. after returning from this function)
20660 SetConsoleCtrlHandler (NULL
, TRUE
);
20667 case CTRL_LOGOFF_EVENT
:
20668 case CTRL_SHUTDOWN_EVENT
:
20672 SetConsoleCtrlHandler (NULL
, TRUE
);
20680 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20684 case CTRL_CLOSE_EVENT
:
20688 SetConsoleCtrlHandler (NULL
, TRUE
);
20695 case CTRL_LOGOFF_EVENT
:
20696 case CTRL_SHUTDOWN_EVENT
:
20700 SetConsoleCtrlHandler (NULL
, TRUE
);
20708 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20710 if (callback
== NULL
)
20712 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20716 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20722 void sigHandler_default (int sig
)
20726 signal (sig
, NULL
);
20729 void sigHandler_benchmark (int sig
)
20733 signal (sig
, NULL
);
20736 void hc_signal (void (callback
) (int))
20738 if (callback
== NULL
) callback
= SIG_DFL
;
20740 signal (SIGINT
, callback
);
20741 signal (SIGTERM
, callback
);
20742 signal (SIGABRT
, callback
);
20747 void status_display ();
20749 void *thread_keypress (void *p
)
20751 int benchmark
= *((int *) p
);
20753 uint quiet
= data
.quiet
;
20757 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20759 int ch
= tty_getchar();
20761 if (ch
== -1) break;
20763 if (ch
== 0) continue;
20765 //https://github.com/hashcat/hashcat/issues/302
20770 hc_thread_mutex_lock (mux_display
);
20786 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20787 if (quiet
== 0) fflush (stdout
);
20799 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20800 if (quiet
== 0) fflush (stdout
);
20812 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20813 if (quiet
== 0) fflush (stdout
);
20825 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20826 if (quiet
== 0) fflush (stdout
);
20834 if (benchmark
== 1) break;
20836 stop_at_checkpoint ();
20840 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20841 if (quiet
== 0) fflush (stdout
);
20849 if (benchmark
== 1)
20861 //https://github.com/hashcat/hashcat/issues/302
20866 hc_thread_mutex_unlock (mux_display
);
20878 bool class_num (const u8 c
)
20880 return ((c
>= '0') && (c
<= '9'));
20883 bool class_lower (const u8 c
)
20885 return ((c
>= 'a') && (c
<= 'z'));
20888 bool class_upper (const u8 c
)
20890 return ((c
>= 'A') && (c
<= 'Z'));
20893 bool class_alpha (const u8 c
)
20895 return (class_lower (c
) || class_upper (c
));
20898 int conv_ctoi (const u8 c
)
20904 else if (class_upper (c
))
20906 return c
- 'A' + 10;
20912 int conv_itoc (const u8 c
)
20920 return c
+ 'A' - 10;
20930 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20931 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20932 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20933 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20934 #define MAX_KERNEL_RULES 255
20935 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20936 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20937 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20939 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20940 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20941 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20942 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20944 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20949 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20951 switch (rule_buf
[rule_pos
])
20957 case RULE_OP_MANGLE_NOOP
:
20958 SET_NAME (rule
, rule_buf
[rule_pos
]);
20961 case RULE_OP_MANGLE_LREST
:
20962 SET_NAME (rule
, rule_buf
[rule_pos
]);
20965 case RULE_OP_MANGLE_UREST
:
20966 SET_NAME (rule
, rule_buf
[rule_pos
]);
20969 case RULE_OP_MANGLE_LREST_UFIRST
:
20970 SET_NAME (rule
, rule_buf
[rule_pos
]);
20973 case RULE_OP_MANGLE_UREST_LFIRST
:
20974 SET_NAME (rule
, rule_buf
[rule_pos
]);
20977 case RULE_OP_MANGLE_TREST
:
20978 SET_NAME (rule
, rule_buf
[rule_pos
]);
20981 case RULE_OP_MANGLE_TOGGLE_AT
:
20982 SET_NAME (rule
, rule_buf
[rule_pos
]);
20983 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20986 case RULE_OP_MANGLE_REVERSE
:
20987 SET_NAME (rule
, rule_buf
[rule_pos
]);
20990 case RULE_OP_MANGLE_DUPEWORD
:
20991 SET_NAME (rule
, rule_buf
[rule_pos
]);
20994 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20995 SET_NAME (rule
, rule_buf
[rule_pos
]);
20996 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20999 case RULE_OP_MANGLE_REFLECT
:
21000 SET_NAME (rule
, rule_buf
[rule_pos
]);
21003 case RULE_OP_MANGLE_ROTATE_LEFT
:
21004 SET_NAME (rule
, rule_buf
[rule_pos
]);
21007 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21008 SET_NAME (rule
, rule_buf
[rule_pos
]);
21011 case RULE_OP_MANGLE_APPEND
:
21012 SET_NAME (rule
, rule_buf
[rule_pos
]);
21013 SET_P0 (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_PREPEND
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21018 SET_P0 (rule
, rule_buf
[rule_pos
]);
21021 case RULE_OP_MANGLE_DELETE_FIRST
:
21022 SET_NAME (rule
, rule_buf
[rule_pos
]);
21025 case RULE_OP_MANGLE_DELETE_LAST
:
21026 SET_NAME (rule
, rule_buf
[rule_pos
]);
21029 case RULE_OP_MANGLE_DELETE_AT
:
21030 SET_NAME (rule
, rule_buf
[rule_pos
]);
21031 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21034 case RULE_OP_MANGLE_EXTRACT
:
21035 SET_NAME (rule
, rule_buf
[rule_pos
]);
21036 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21037 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21040 case RULE_OP_MANGLE_OMIT
:
21041 SET_NAME (rule
, rule_buf
[rule_pos
]);
21042 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21043 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21046 case RULE_OP_MANGLE_INSERT
:
21047 SET_NAME (rule
, rule_buf
[rule_pos
]);
21048 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21049 SET_P1 (rule
, rule_buf
[rule_pos
]);
21052 case RULE_OP_MANGLE_OVERSTRIKE
:
21053 SET_NAME (rule
, rule_buf
[rule_pos
]);
21054 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21055 SET_P1 (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_TRUNCATE_AT
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21063 case RULE_OP_MANGLE_REPLACE
:
21064 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 SET_P0 (rule
, rule_buf
[rule_pos
]);
21066 SET_P1 (rule
, rule_buf
[rule_pos
]);
21069 case RULE_OP_MANGLE_PURGECHAR
:
21073 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21077 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21078 SET_NAME (rule
, rule_buf
[rule_pos
]);
21079 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21082 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21083 SET_NAME (rule
, rule_buf
[rule_pos
]);
21084 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21087 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21088 SET_NAME (rule
, rule_buf
[rule_pos
]);
21091 case RULE_OP_MANGLE_SWITCH_FIRST
:
21092 SET_NAME (rule
, rule_buf
[rule_pos
]);
21095 case RULE_OP_MANGLE_SWITCH_LAST
:
21096 SET_NAME (rule
, rule_buf
[rule_pos
]);
21099 case RULE_OP_MANGLE_SWITCH_AT
:
21100 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21102 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21105 case RULE_OP_MANGLE_CHR_SHIFTL
:
21106 SET_NAME (rule
, rule_buf
[rule_pos
]);
21107 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21110 case RULE_OP_MANGLE_CHR_SHIFTR
:
21111 SET_NAME (rule
, rule_buf
[rule_pos
]);
21112 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21115 case RULE_OP_MANGLE_CHR_INCR
:
21116 SET_NAME (rule
, rule_buf
[rule_pos
]);
21117 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21120 case RULE_OP_MANGLE_CHR_DECR
:
21121 SET_NAME (rule
, rule_buf
[rule_pos
]);
21122 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21125 case RULE_OP_MANGLE_REPLACE_NP1
:
21126 SET_NAME (rule
, rule_buf
[rule_pos
]);
21127 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21130 case RULE_OP_MANGLE_REPLACE_NM1
:
21131 SET_NAME (rule
, rule_buf
[rule_pos
]);
21132 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21135 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21136 SET_NAME (rule
, rule_buf
[rule_pos
]);
21137 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21140 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21141 SET_NAME (rule
, rule_buf
[rule_pos
]);
21142 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21145 case RULE_OP_MANGLE_TITLE
:
21146 SET_NAME (rule
, rule_buf
[rule_pos
]);
21155 if (rule_pos
< rule_len
) return (-1);
21160 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21164 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21168 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21172 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21176 case RULE_OP_MANGLE_NOOP
:
21177 rule_buf
[rule_pos
] = rule_cmd
;
21180 case RULE_OP_MANGLE_LREST
:
21181 rule_buf
[rule_pos
] = rule_cmd
;
21184 case RULE_OP_MANGLE_UREST
:
21185 rule_buf
[rule_pos
] = rule_cmd
;
21188 case RULE_OP_MANGLE_LREST_UFIRST
:
21189 rule_buf
[rule_pos
] = rule_cmd
;
21192 case RULE_OP_MANGLE_UREST_LFIRST
:
21193 rule_buf
[rule_pos
] = rule_cmd
;
21196 case RULE_OP_MANGLE_TREST
:
21197 rule_buf
[rule_pos
] = rule_cmd
;
21200 case RULE_OP_MANGLE_TOGGLE_AT
:
21201 rule_buf
[rule_pos
] = rule_cmd
;
21202 GET_P0_CONV (rule
);
21205 case RULE_OP_MANGLE_REVERSE
:
21206 rule_buf
[rule_pos
] = rule_cmd
;
21209 case RULE_OP_MANGLE_DUPEWORD
:
21210 rule_buf
[rule_pos
] = rule_cmd
;
21213 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21214 rule_buf
[rule_pos
] = rule_cmd
;
21215 GET_P0_CONV (rule
);
21218 case RULE_OP_MANGLE_REFLECT
:
21219 rule_buf
[rule_pos
] = rule_cmd
;
21222 case RULE_OP_MANGLE_ROTATE_LEFT
:
21223 rule_buf
[rule_pos
] = rule_cmd
;
21226 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21227 rule_buf
[rule_pos
] = rule_cmd
;
21230 case RULE_OP_MANGLE_APPEND
:
21231 rule_buf
[rule_pos
] = rule_cmd
;
21235 case RULE_OP_MANGLE_PREPEND
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21240 case RULE_OP_MANGLE_DELETE_FIRST
:
21241 rule_buf
[rule_pos
] = rule_cmd
;
21244 case RULE_OP_MANGLE_DELETE_LAST
:
21245 rule_buf
[rule_pos
] = rule_cmd
;
21248 case RULE_OP_MANGLE_DELETE_AT
:
21249 rule_buf
[rule_pos
] = rule_cmd
;
21250 GET_P0_CONV (rule
);
21253 case RULE_OP_MANGLE_EXTRACT
:
21254 rule_buf
[rule_pos
] = rule_cmd
;
21255 GET_P0_CONV (rule
);
21256 GET_P1_CONV (rule
);
21259 case RULE_OP_MANGLE_OMIT
:
21260 rule_buf
[rule_pos
] = rule_cmd
;
21261 GET_P0_CONV (rule
);
21262 GET_P1_CONV (rule
);
21265 case RULE_OP_MANGLE_INSERT
:
21266 rule_buf
[rule_pos
] = rule_cmd
;
21267 GET_P0_CONV (rule
);
21271 case RULE_OP_MANGLE_OVERSTRIKE
:
21272 rule_buf
[rule_pos
] = rule_cmd
;
21273 GET_P0_CONV (rule
);
21277 case RULE_OP_MANGLE_TRUNCATE_AT
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21279 GET_P0_CONV (rule
);
21282 case RULE_OP_MANGLE_REPLACE
:
21283 rule_buf
[rule_pos
] = rule_cmd
;
21288 case RULE_OP_MANGLE_PURGECHAR
:
21292 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21296 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21297 rule_buf
[rule_pos
] = rule_cmd
;
21298 GET_P0_CONV (rule
);
21301 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21302 rule_buf
[rule_pos
] = rule_cmd
;
21303 GET_P0_CONV (rule
);
21306 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21307 rule_buf
[rule_pos
] = rule_cmd
;
21310 case RULE_OP_MANGLE_SWITCH_FIRST
:
21311 rule_buf
[rule_pos
] = rule_cmd
;
21314 case RULE_OP_MANGLE_SWITCH_LAST
:
21315 rule_buf
[rule_pos
] = rule_cmd
;
21318 case RULE_OP_MANGLE_SWITCH_AT
:
21319 rule_buf
[rule_pos
] = rule_cmd
;
21320 GET_P0_CONV (rule
);
21321 GET_P1_CONV (rule
);
21324 case RULE_OP_MANGLE_CHR_SHIFTL
:
21325 rule_buf
[rule_pos
] = rule_cmd
;
21326 GET_P0_CONV (rule
);
21329 case RULE_OP_MANGLE_CHR_SHIFTR
:
21330 rule_buf
[rule_pos
] = rule_cmd
;
21331 GET_P0_CONV (rule
);
21334 case RULE_OP_MANGLE_CHR_INCR
:
21335 rule_buf
[rule_pos
] = rule_cmd
;
21336 GET_P0_CONV (rule
);
21339 case RULE_OP_MANGLE_CHR_DECR
:
21340 rule_buf
[rule_pos
] = rule_cmd
;
21341 GET_P0_CONV (rule
);
21344 case RULE_OP_MANGLE_REPLACE_NP1
:
21345 rule_buf
[rule_pos
] = rule_cmd
;
21346 GET_P0_CONV (rule
);
21349 case RULE_OP_MANGLE_REPLACE_NM1
:
21350 rule_buf
[rule_pos
] = rule_cmd
;
21351 GET_P0_CONV (rule
);
21354 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21355 rule_buf
[rule_pos
] = rule_cmd
;
21356 GET_P0_CONV (rule
);
21359 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21360 rule_buf
[rule_pos
] = rule_cmd
;
21361 GET_P0_CONV (rule
);
21364 case RULE_OP_MANGLE_TITLE
:
21365 rule_buf
[rule_pos
] = rule_cmd
;
21369 return rule_pos
- 1;
21387 * CPU rules : this is from hashcat sources, cpu based rules
21390 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21391 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21393 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21394 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21395 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21397 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21398 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21399 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21401 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21405 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21410 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21414 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21419 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21423 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21428 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21433 for (l
= 0; l
< arr_len
; l
++)
21435 r
= arr_len
- 1 - l
;
21439 MANGLE_SWITCH (arr
, l
, r
);
21445 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21447 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21449 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21451 return (arr_len
* 2);
21454 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21456 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21458 int orig_len
= arr_len
;
21462 for (i
= 0; i
< times
; i
++)
21464 memcpy (&arr
[arr_len
], arr
, orig_len
);
21466 arr_len
+= orig_len
;
21472 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21474 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21476 mangle_double (arr
, arr_len
);
21478 mangle_reverse (arr
+ arr_len
, arr_len
);
21480 return (arr_len
* 2);
21483 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21488 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21490 MANGLE_SWITCH (arr
, l
, r
);
21496 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21501 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21503 MANGLE_SWITCH (arr
, l
, r
);
21509 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21511 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21515 return (arr_len
+ 1);
21518 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21520 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21524 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21526 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21531 return (arr_len
+ 1);
21534 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21536 if (upos
>= arr_len
) return (arr_len
);
21540 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21542 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21545 return (arr_len
- 1);
21548 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21550 if (upos
>= arr_len
) return (arr_len
);
21552 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21556 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21558 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21564 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21566 if (upos
>= arr_len
) return (arr_len
);
21568 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21572 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21574 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21577 return (arr_len
- ulen
);
21580 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21582 if (upos
>= arr_len
) return (arr_len
);
21584 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21588 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21590 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21595 return (arr_len
+ 1);
21598 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
)
21600 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21602 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21604 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21606 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21608 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21610 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21612 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21614 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21616 return (arr_len
+ arr2_cpy
);
21619 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21621 if (upos
>= arr_len
) return (arr_len
);
21628 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21630 if (upos
>= arr_len
) return (arr_len
);
21632 memset (arr
+ upos
, 0, arr_len
- upos
);
21637 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21641 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21643 if (arr
[arr_pos
] != oldc
) continue;
21645 arr
[arr_pos
] = newc
;
21651 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21657 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21659 if (arr
[arr_pos
] == c
) continue;
21661 arr
[ret_len
] = arr
[arr_pos
];
21669 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21671 if (ulen
> arr_len
) return (arr_len
);
21673 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21675 char cs
[100] = { 0 };
21677 memcpy (cs
, arr
, ulen
);
21681 for (i
= 0; i
< ulen
; i
++)
21685 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21691 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21693 if (ulen
> arr_len
) return (arr_len
);
21695 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21697 int upos
= arr_len
- ulen
;
21701 for (i
= 0; i
< ulen
; i
++)
21703 char c
= arr
[upos
+ i
];
21705 arr_len
= mangle_append (arr
, arr_len
, c
);
21711 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21713 if ( arr_len
== 0) return (arr_len
);
21714 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21716 char c
= arr
[upos
];
21720 for (i
= 0; i
< ulen
; i
++)
21722 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21728 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21730 if ( arr_len
== 0) return (arr_len
);
21731 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21735 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21737 int new_pos
= arr_pos
* 2;
21739 arr
[new_pos
] = arr
[arr_pos
];
21741 arr
[new_pos
+ 1] = arr
[arr_pos
];
21744 return (arr_len
* 2);
21747 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21749 if (upos
>= arr_len
) return (arr_len
);
21750 if (upos2
>= arr_len
) return (arr_len
);
21752 MANGLE_SWITCH (arr
, upos
, upos2
);
21757 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21759 MANGLE_SWITCH (arr
, upos
, upos2
);
21764 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21766 if (upos
>= arr_len
) return (arr_len
);
21773 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21775 if (upos
>= arr_len
) return (arr_len
);
21782 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21784 if (upos
>= arr_len
) return (arr_len
);
21791 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21793 if (upos
>= arr_len
) return (arr_len
);
21800 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21802 int upper_next
= 1;
21806 for (pos
= 0; pos
< arr_len
; pos
++)
21808 if (arr
[pos
] == ' ')
21819 MANGLE_UPPER_AT (arr
, pos
);
21823 MANGLE_LOWER_AT (arr
, pos
);
21830 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21832 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21838 for (j
= 0; j
< rp_gen_num
; j
++)
21845 switch ((char) get_random_num (0, 9))
21848 r
= get_random_num (0, sizeof (grp_op_nop
));
21849 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21853 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21854 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21855 p1
= get_random_num (0, sizeof (grp_pos
));
21856 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21860 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21861 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21862 p1
= get_random_num (1, 6);
21863 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21867 r
= get_random_num (0, sizeof (grp_op_chr
));
21868 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21869 p1
= get_random_num (0x20, 0x7e);
21870 rule_buf
[rule_pos
++] = (char) p1
;
21874 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21875 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21876 p1
= get_random_num (0x20, 0x7e);
21877 rule_buf
[rule_pos
++] = (char) p1
;
21878 p2
= get_random_num (0x20, 0x7e);
21880 p2
= get_random_num (0x20, 0x7e);
21881 rule_buf
[rule_pos
++] = (char) p2
;
21885 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21886 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21887 p1
= get_random_num (0, sizeof (grp_pos
));
21888 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21889 p2
= get_random_num (0x20, 0x7e);
21890 rule_buf
[rule_pos
++] = (char) p2
;
21894 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21895 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21896 p1
= get_random_num (0, sizeof (grp_pos
));
21897 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21898 p2
= get_random_num (0, sizeof (grp_pos
));
21900 p2
= get_random_num (0, sizeof (grp_pos
));
21901 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21905 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21906 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21907 p1
= get_random_num (0, sizeof (grp_pos
));
21908 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21909 p2
= get_random_num (1, sizeof (grp_pos
));
21911 p2
= get_random_num (1, sizeof (grp_pos
));
21912 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21916 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21917 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21918 p1
= get_random_num (0, sizeof (grp_pos
));
21919 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21920 p2
= get_random_num (1, sizeof (grp_pos
));
21921 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21922 p3
= get_random_num (0, sizeof (grp_pos
));
21923 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21931 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21933 char mem
[BLOCK_SIZE
] = { 0 };
21935 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21937 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21939 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21941 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21943 int out_len
= in_len
;
21944 int mem_len
= in_len
;
21946 memcpy (out
, in
, out_len
);
21950 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21955 switch (rule
[rule_pos
])
21960 case RULE_OP_MANGLE_NOOP
:
21963 case RULE_OP_MANGLE_LREST
:
21964 out_len
= mangle_lrest (out
, out_len
);
21967 case RULE_OP_MANGLE_UREST
:
21968 out_len
= mangle_urest (out
, out_len
);
21971 case RULE_OP_MANGLE_LREST_UFIRST
:
21972 out_len
= mangle_lrest (out
, out_len
);
21973 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21976 case RULE_OP_MANGLE_UREST_LFIRST
:
21977 out_len
= mangle_urest (out
, out_len
);
21978 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21981 case RULE_OP_MANGLE_TREST
:
21982 out_len
= mangle_trest (out
, out_len
);
21985 case RULE_OP_MANGLE_TOGGLE_AT
:
21986 NEXT_RULEPOS (rule_pos
);
21987 NEXT_RPTOI (rule
, rule_pos
, upos
);
21988 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21991 case RULE_OP_MANGLE_REVERSE
:
21992 out_len
= mangle_reverse (out
, out_len
);
21995 case RULE_OP_MANGLE_DUPEWORD
:
21996 out_len
= mangle_double (out
, out_len
);
21999 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22000 NEXT_RULEPOS (rule_pos
);
22001 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22002 out_len
= mangle_double_times (out
, out_len
, ulen
);
22005 case RULE_OP_MANGLE_REFLECT
:
22006 out_len
= mangle_reflect (out
, out_len
);
22009 case RULE_OP_MANGLE_ROTATE_LEFT
:
22010 mangle_rotate_left (out
, out_len
);
22013 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22014 mangle_rotate_right (out
, out_len
);
22017 case RULE_OP_MANGLE_APPEND
:
22018 NEXT_RULEPOS (rule_pos
);
22019 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22022 case RULE_OP_MANGLE_PREPEND
:
22023 NEXT_RULEPOS (rule_pos
);
22024 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22027 case RULE_OP_MANGLE_DELETE_FIRST
:
22028 out_len
= mangle_delete_at (out
, out_len
, 0);
22031 case RULE_OP_MANGLE_DELETE_LAST
:
22032 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22035 case RULE_OP_MANGLE_DELETE_AT
:
22036 NEXT_RULEPOS (rule_pos
);
22037 NEXT_RPTOI (rule
, rule_pos
, upos
);
22038 out_len
= mangle_delete_at (out
, out_len
, upos
);
22041 case RULE_OP_MANGLE_EXTRACT
:
22042 NEXT_RULEPOS (rule_pos
);
22043 NEXT_RPTOI (rule
, rule_pos
, upos
);
22044 NEXT_RULEPOS (rule_pos
);
22045 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22046 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22049 case RULE_OP_MANGLE_OMIT
:
22050 NEXT_RULEPOS (rule_pos
);
22051 NEXT_RPTOI (rule
, rule_pos
, upos
);
22052 NEXT_RULEPOS (rule_pos
);
22053 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22054 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22057 case RULE_OP_MANGLE_INSERT
:
22058 NEXT_RULEPOS (rule_pos
);
22059 NEXT_RPTOI (rule
, rule_pos
, upos
);
22060 NEXT_RULEPOS (rule_pos
);
22061 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22064 case RULE_OP_MANGLE_OVERSTRIKE
:
22065 NEXT_RULEPOS (rule_pos
);
22066 NEXT_RPTOI (rule
, rule_pos
, upos
);
22067 NEXT_RULEPOS (rule_pos
);
22068 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22071 case RULE_OP_MANGLE_TRUNCATE_AT
:
22072 NEXT_RULEPOS (rule_pos
);
22073 NEXT_RPTOI (rule
, rule_pos
, upos
);
22074 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22077 case RULE_OP_MANGLE_REPLACE
:
22078 NEXT_RULEPOS (rule_pos
);
22079 NEXT_RULEPOS (rule_pos
);
22080 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22083 case RULE_OP_MANGLE_PURGECHAR
:
22084 NEXT_RULEPOS (rule_pos
);
22085 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22088 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22092 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22093 NEXT_RULEPOS (rule_pos
);
22094 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22095 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22098 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22099 NEXT_RULEPOS (rule_pos
);
22100 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22101 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22104 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22105 out_len
= mangle_dupechar (out
, out_len
);
22108 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22109 NEXT_RULEPOS (rule_pos
);
22110 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22111 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22114 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22115 NEXT_RULEPOS (rule_pos
);
22116 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22117 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22120 case RULE_OP_MANGLE_SWITCH_FIRST
:
22121 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22124 case RULE_OP_MANGLE_SWITCH_LAST
:
22125 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22128 case RULE_OP_MANGLE_SWITCH_AT
:
22129 NEXT_RULEPOS (rule_pos
);
22130 NEXT_RPTOI (rule
, rule_pos
, upos
);
22131 NEXT_RULEPOS (rule_pos
);
22132 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22133 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22136 case RULE_OP_MANGLE_CHR_SHIFTL
:
22137 NEXT_RULEPOS (rule_pos
);
22138 NEXT_RPTOI (rule
, rule_pos
, upos
);
22139 mangle_chr_shiftl (out
, out_len
, upos
);
22142 case RULE_OP_MANGLE_CHR_SHIFTR
:
22143 NEXT_RULEPOS (rule_pos
);
22144 NEXT_RPTOI (rule
, rule_pos
, upos
);
22145 mangle_chr_shiftr (out
, out_len
, upos
);
22148 case RULE_OP_MANGLE_CHR_INCR
:
22149 NEXT_RULEPOS (rule_pos
);
22150 NEXT_RPTOI (rule
, rule_pos
, upos
);
22151 mangle_chr_incr (out
, out_len
, upos
);
22154 case RULE_OP_MANGLE_CHR_DECR
:
22155 NEXT_RULEPOS (rule_pos
);
22156 NEXT_RPTOI (rule
, rule_pos
, upos
);
22157 mangle_chr_decr (out
, out_len
, upos
);
22160 case RULE_OP_MANGLE_REPLACE_NP1
:
22161 NEXT_RULEPOS (rule_pos
);
22162 NEXT_RPTOI (rule
, rule_pos
, upos
);
22163 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22166 case RULE_OP_MANGLE_REPLACE_NM1
:
22167 NEXT_RULEPOS (rule_pos
);
22168 NEXT_RPTOI (rule
, rule_pos
, upos
);
22169 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22172 case RULE_OP_MANGLE_TITLE
:
22173 out_len
= mangle_title (out
, out_len
);
22176 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22177 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22178 NEXT_RULEPOS (rule_pos
);
22179 NEXT_RPTOI (rule
, rule_pos
, upos
);
22180 NEXT_RULEPOS (rule_pos
);
22181 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22182 NEXT_RULEPOS (rule_pos
);
22183 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22184 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22187 case RULE_OP_MANGLE_APPEND_MEMORY
:
22188 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22189 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22190 memcpy (out
+ out_len
, mem
, mem_len
);
22191 out_len
+= mem_len
;
22194 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22195 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22196 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22197 memcpy (mem
+ mem_len
, out
, out_len
);
22198 out_len
+= mem_len
;
22199 memcpy (out
, mem
, out_len
);
22202 case RULE_OP_MEMORIZE_WORD
:
22203 memcpy (mem
, out
, out_len
);
22207 case RULE_OP_REJECT_LESS
:
22208 NEXT_RULEPOS (rule_pos
);
22209 NEXT_RPTOI (rule
, rule_pos
, upos
);
22210 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22213 case RULE_OP_REJECT_GREATER
:
22214 NEXT_RULEPOS (rule_pos
);
22215 NEXT_RPTOI (rule
, rule_pos
, upos
);
22216 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22219 case RULE_OP_REJECT_CONTAIN
:
22220 NEXT_RULEPOS (rule_pos
);
22221 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22224 case RULE_OP_REJECT_NOT_CONTAIN
:
22225 NEXT_RULEPOS (rule_pos
);
22226 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22229 case RULE_OP_REJECT_EQUAL_FIRST
:
22230 NEXT_RULEPOS (rule_pos
);
22231 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22234 case RULE_OP_REJECT_EQUAL_LAST
:
22235 NEXT_RULEPOS (rule_pos
);
22236 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22239 case RULE_OP_REJECT_EQUAL_AT
:
22240 NEXT_RULEPOS (rule_pos
);
22241 NEXT_RPTOI (rule
, rule_pos
, upos
);
22242 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22243 NEXT_RULEPOS (rule_pos
);
22244 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22247 case RULE_OP_REJECT_CONTAINS
:
22248 NEXT_RULEPOS (rule_pos
);
22249 NEXT_RPTOI (rule
, rule_pos
, upos
);
22250 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22251 NEXT_RULEPOS (rule_pos
);
22252 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22253 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22256 case RULE_OP_REJECT_MEMORY
:
22257 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22261 return (RULE_RC_SYNTAX_ERROR
);
22266 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);