2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
9 #if defined(DARWIN) || defined(__FreeBSD__)
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 termios savemodes
;
2338 static int havemodes
= 0;
2342 struct termios modmodes
;
2344 if (tcgetattr (fileno (stdin
), &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 tcsetattr (fileno (stdin
), TCSANOW
, &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 tcsetattr (fileno (stdin
), TCSADRAIN
, &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
;
3406 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonGpuIdle
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonApplicationsClocksSetting
;
3408 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3410 if (data
.kernel_power_final
)
3412 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonHwSlowdown
;
3415 return (clocksThrottleReasons
!= nvmlClocksThrottleReasonNone
);
3421 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3423 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3429 if (data
.hm_device
[device_id
].od_version
== 5)
3431 ADLFanSpeedValue lpFanSpeedValue
;
3433 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3435 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3436 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3437 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3438 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3440 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3444 else // od_version == 6
3446 ADLOD6FanSpeedValue fan_speed_value
;
3448 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3450 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3451 fan_speed_value
.iFanSpeed
= fanspeed
;
3453 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3460 if (data
.hm_device
[device_id
].od_version
== 5)
3462 if (hm_ADL_Overdrive5_FanSpeedToDefault_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0) != ADL_OK
) return -1;
3466 else // od_version == 6
3468 if (hm_ADL_Overdrive6_FanSpeed_Reset (data
.hm_adl
, data
.hm_device
[device_id
].adl
) != ADL_OK
) return -1;
3479 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3481 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3487 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3489 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3491 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3492 CoolerLevels
.Levels
[0].Policy
= 1;
3494 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3500 if (hm_NvAPI_GPU_RestoreCoolerSettings (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0) != NVAPI_OK
) return -1;
3510 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3512 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3514 if (data
.hm_xnvctrl
)
3516 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3525 #endif // HAVE_HWMON
3531 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3533 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3535 if (css_cnt
> SP_PW_MAX
)
3537 log_error ("ERROR: Mask length is too long");
3542 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3544 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3546 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3547 uint cs_len
= css
[css_pos
].cs_len
;
3549 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3551 uint c
= cs_buf
[cs_pos
] & 0xff;
3558 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3560 cs_t
*cs
= &css
[css_cnt
];
3562 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3564 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3568 for (i
= 0; i
< cs
->cs_len
; i
++)
3570 const uint u
= cs
->cs_buf
[i
];
3575 for (i
= 0; i
< in_len
; i
++)
3577 uint u
= in_buf
[i
] & 0xff;
3579 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3581 if (css_uniq
[u
] == 1) continue;
3585 cs
->cs_buf
[cs
->cs_len
] = u
;
3593 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3597 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3599 uint p0
= in_buf
[in_pos
] & 0xff;
3601 if (interpret
== 1 && p0
== '?')
3605 if (in_pos
== in_len
) break;
3607 uint p1
= in_buf
[in_pos
] & 0xff;
3611 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3613 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3615 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3617 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3619 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3621 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3623 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3624 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3626 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3627 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3629 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3630 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3632 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3633 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3635 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3637 default: log_error ("Syntax error: %s", in_buf
);
3643 if (data
.hex_charset
)
3647 if (in_pos
== in_len
)
3649 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3654 uint p1
= in_buf
[in_pos
] & 0xff;
3656 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3658 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3665 chr
= hex_convert (p1
) << 0;
3666 chr
|= hex_convert (p0
) << 4;
3668 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3674 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3680 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3684 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3686 sum
*= css
[css_pos
].cs_len
;
3692 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3694 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3699 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3701 char p0
= mask_buf
[mask_pos
];
3707 if (mask_pos
== mask_len
) break;
3709 char p1
= mask_buf
[mask_pos
];
3715 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3717 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3719 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3721 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3723 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3725 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3727 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3728 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3730 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3731 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3733 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3734 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3736 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3737 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3739 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3741 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3747 if (data
.hex_charset
)
3751 // if there is no 2nd hex character, show an error:
3753 if (mask_pos
== mask_len
)
3755 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3760 char p1
= mask_buf
[mask_pos
];
3762 // if they are not valid hex character, show an error:
3764 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3766 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3773 chr
|= hex_convert (p1
) << 0;
3774 chr
|= hex_convert (p0
) << 4;
3776 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3782 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3789 log_error ("ERROR: Invalid mask length (0)");
3799 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3801 for (int i
= 0; i
< css_cnt
; i
++)
3803 uint len
= css
[i
].cs_len
;
3804 u64 next
= val
/ len
;
3805 uint pos
= val
% len
;
3806 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3811 void mp_cut_at (char *mask
, uint max
)
3815 uint mask_len
= strlen (mask
);
3817 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3819 if (mask
[i
] == '?') i
++;
3825 void mp_setup_sys (cs_t
*mp_sys
)
3829 uint donec
[CHARSIZ
] = { 0 };
3831 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3832 mp_sys
[0].cs_buf
[pos
++] = chr
;
3833 mp_sys
[0].cs_len
= pos
; }
3835 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3836 mp_sys
[1].cs_buf
[pos
++] = chr
;
3837 mp_sys
[1].cs_len
= pos
; }
3839 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3840 mp_sys
[2].cs_buf
[pos
++] = chr
;
3841 mp_sys
[2].cs_len
= pos
; }
3843 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3844 mp_sys
[3].cs_buf
[pos
++] = chr
;
3845 mp_sys
[3].cs_len
= pos
; }
3847 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3848 mp_sys
[4].cs_len
= pos
; }
3850 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3851 mp_sys
[5].cs_len
= pos
; }
3854 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3856 FILE *fp
= fopen (buf
, "rb");
3858 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3860 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3864 char mp_file
[1024] = { 0 };
3866 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3870 len
= in_superchop (mp_file
);
3874 log_info ("WARNING: Charset file corrupted");
3876 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3880 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3885 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3887 mp_usr
[index
].cs_len
= 0;
3889 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3892 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3894 char *new_mask_buf
= (char *) mymalloc (256);
3900 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3902 if (css_pos
== len
) break;
3904 char p0
= mask_buf
[mask_pos
];
3906 new_mask_buf
[mask_pos
] = p0
;
3912 if (mask_pos
== mask_len
) break;
3914 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3918 if (data
.hex_charset
)
3922 if (mask_pos
== mask_len
)
3924 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3929 char p1
= mask_buf
[mask_pos
];
3931 // if they are not valid hex character, show an error:
3933 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3935 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3940 new_mask_buf
[mask_pos
] = p1
;
3945 if (css_pos
== len
) return (new_mask_buf
);
3947 myfree (new_mask_buf
);
3956 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3962 for (i
= start
; i
< stop
; i
++)
3964 sum
*= root_css_buf
[i
].cs_len
;
3970 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3974 cs_t
*cs
= &root_css_buf
[start
];
3978 for (i
= start
; i
< stop
; i
++)
3980 const u64 m
= v
% cs
->cs_len
;
3981 const u64 d
= v
/ cs
->cs_len
;
3985 const uint k
= cs
->cs_buf
[m
];
3987 pw_buf
[i
- start
] = (char) k
;
3989 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3993 int sp_comp_val (const void *p1
, const void *p2
)
3995 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3996 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3998 return b2
->val
- b1
->val
;
4001 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
)
4008 * Initialize hcstats
4011 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4013 u64
*root_stats_ptr
= root_stats_buf
;
4015 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4017 for (i
= 0; i
< SP_PW_MAX
; i
++)
4019 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4021 root_stats_ptr
+= CHARSIZ
;
4024 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4026 u64
*markov_stats_ptr
= markov_stats_buf
;
4028 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4030 for (i
= 0; i
< SP_PW_MAX
; i
++)
4032 for (j
= 0; j
< CHARSIZ
; j
++)
4034 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4036 markov_stats_ptr
+= CHARSIZ
;
4046 char hcstat_tmp
[256] = { 0 };
4048 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4050 hcstat
= hcstat_tmp
;
4053 FILE *fd
= fopen (hcstat
, "rb");
4057 log_error ("%s: %s", hcstat
, strerror (errno
));
4062 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4064 log_error ("%s: Could not load data", hcstat
);
4071 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4073 log_error ("%s: Could not load data", hcstat
);
4083 * Markov modifier of hcstat_table on user request
4088 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4089 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4094 /* Add all stats to first position */
4096 for (i
= 1; i
< SP_PW_MAX
; i
++)
4098 u64
*out
= root_stats_buf_by_pos
[0];
4099 u64
*in
= root_stats_buf_by_pos
[i
];
4101 for (j
= 0; j
< CHARSIZ
; j
++)
4107 for (i
= 1; i
< SP_PW_MAX
; i
++)
4109 u64
*out
= markov_stats_buf_by_key
[0][0];
4110 u64
*in
= markov_stats_buf_by_key
[i
][0];
4112 for (j
= 0; j
< CHARSIZ
; j
++)
4114 for (k
= 0; k
< CHARSIZ
; k
++)
4121 /* copy them to all pw_positions */
4123 for (i
= 1; i
< SP_PW_MAX
; i
++)
4125 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4128 for (i
= 1; i
< SP_PW_MAX
; i
++)
4130 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4138 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4140 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4142 for (i
= 0; i
< SP_PW_MAX
; i
++)
4144 root_table_buf_by_pos
[i
] = root_table_ptr
;
4146 root_table_ptr
+= CHARSIZ
;
4149 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4151 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4153 for (i
= 0; i
< SP_PW_MAX
; i
++)
4155 for (j
= 0; j
< CHARSIZ
; j
++)
4157 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4159 markov_table_ptr
+= CHARSIZ
;
4164 * Convert hcstat to tables
4167 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4169 uint key
= i
% CHARSIZ
;
4171 root_table_buf
[i
].key
= key
;
4172 root_table_buf
[i
].val
= root_stats_buf
[i
];
4175 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4177 uint key
= i
% CHARSIZ
;
4179 markov_table_buf
[i
].key
= key
;
4180 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4183 myfree (root_stats_buf
);
4184 myfree (markov_stats_buf
);
4190 for (i
= 0; i
< SP_PW_MAX
; i
++)
4192 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4195 for (i
= 0; i
< SP_PW_MAX
; i
++)
4197 for (j
= 0; j
< CHARSIZ
; j
++)
4199 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4204 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
])
4207 * Convert tables to css
4210 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4212 uint pw_pos
= i
/ CHARSIZ
;
4214 cs_t
*cs
= &root_css_buf
[pw_pos
];
4216 if (cs
->cs_len
== threshold
) continue;
4218 uint key
= root_table_buf
[i
].key
;
4220 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4222 cs
->cs_buf
[cs
->cs_len
] = key
;
4228 * Convert table to css
4231 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4233 uint c
= i
/ CHARSIZ
;
4235 cs_t
*cs
= &markov_css_buf
[c
];
4237 if (cs
->cs_len
== threshold
) continue;
4239 uint pw_pos
= c
/ CHARSIZ
;
4241 uint key
= markov_table_buf
[i
].key
;
4243 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4245 cs
->cs_buf
[cs
->cs_len
] = key
;
4251 for (uint i = 0; i < 8; i++)
4253 for (uint j = 0x20; j < 0x80; j++)
4255 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4257 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4259 for (uint k = 0; k < 10; k++)
4261 printf (" %u\n", ptr->cs_buf[k]);
4268 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4270 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4272 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4282 for (uint j
= 1; j
< CHARSIZ
; j
++)
4292 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4294 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4296 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4298 out
+= CHARSIZ
* CHARSIZ
;
4299 in
+= CHARSIZ
* CHARSIZ
;
4301 for (uint j
= 0; j
< CHARSIZ
; j
++)
4308 for (uint k
= 1; k
< CHARSIZ
; k
++)
4320 * mixed shared functions
4323 void dump_hex (const u8
*s
, const int sz
)
4325 for (int i
= 0; i
< sz
; i
++)
4327 log_info_nn ("%02x ", s
[i
]);
4333 void usage_mini_print (const char *progname
)
4335 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4338 void usage_big_print (const char *progname
)
4340 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4343 char *get_exec_path ()
4345 int exec_path_len
= 1024;
4347 char *exec_path
= (char *) mymalloc (exec_path_len
);
4351 char tmp
[32] = { 0 };
4353 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4355 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4359 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4363 uint size
= exec_path_len
;
4365 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4367 log_error("! executable path buffer too small\n");
4372 const int len
= strlen (exec_path
);
4376 #include <sys/sysctl.h>
4381 mib
[2] = KERN_PROC_PATHNAME
;
4384 size_t size
= sizeof(exec_path
);
4386 const int len
= sysctl(mib
, 4, exec_path
, &size
, NULL
, 0);
4389 #error Your Operating System is not supported or detected
4397 char *get_install_dir (const char *progname
)
4399 char *install_dir
= mystrdup (progname
);
4400 char *last_slash
= NULL
;
4402 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4406 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4412 install_dir
[0] = '.';
4416 return (install_dir
);
4419 char *get_profile_dir (const char *homedir
)
4421 #define DOT_HASHCAT ".hashcat"
4423 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4425 char *profile_dir
= (char *) mymalloc (len
+ 1);
4427 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4432 char *get_session_dir (const char *profile_dir
)
4434 #define SESSIONS_FOLDER "sessions"
4436 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4438 char *session_dir
= (char *) mymalloc (len
+ 1);
4440 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4445 uint
count_lines (FILE *fd
)
4449 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4455 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4457 if (nread
< 1) continue;
4461 for (i
= 0; i
< nread
; i
++)
4463 if (prev
== '\n') cnt
++;
4474 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4478 FILE *fd
= fopen (filename
, "rb");
4482 log_error ("%s: %s", filename
, strerror (errno
));
4487 #define MAX_KEY_SIZE (1024 * 1024)
4489 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4491 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4497 for (int fpos
= 0; fpos
< nread
; fpos
++)
4499 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4501 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4502 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4503 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4504 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4506 if (kpos
>= 64) kpos
= 0;
4513 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4517 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4518 if (CPU_ISSET(core
, cpu_set
)) break;
4520 thread_affinity_policy_data_t policy
= { core
};
4522 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4524 if (data
.quiet
== 0)
4526 if (rc
!= KERN_SUCCESS
)
4528 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4536 void set_cpu_affinity (char *cpu_affinity
)
4539 DWORD_PTR aff_mask
= 0;
4547 char *devices
= strdup (cpu_affinity
);
4549 char *next
= strtok (devices
, ",");
4553 uint cpu_id
= atoi (next
);
4568 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4574 aff_mask
|= 1 << (cpu_id
- 1);
4576 CPU_SET ((cpu_id
- 1), &cpuset
);
4579 } while ((next
= strtok (NULL
, ",")) != NULL
);
4585 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4586 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4588 pthread_t thread
= pthread_self ();
4589 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4593 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4595 char *element
, *end
;
4597 end
= (char *) base
+ nmemb
* size
;
4599 for (element
= (char *) base
; element
< end
; element
+= size
)
4600 if (!compar (element
, key
))
4606 int sort_by_u32 (const void *v1
, const void *v2
)
4608 const u32
*s1
= (const u32
*) v1
;
4609 const u32
*s2
= (const u32
*) v2
;
4614 int sort_by_salt (const void *v1
, const void *v2
)
4616 const salt_t
*s1
= (const salt_t
*) v1
;
4617 const salt_t
*s2
= (const salt_t
*) v2
;
4619 const int res1
= s1
->salt_len
- s2
->salt_len
;
4621 if (res1
!= 0) return (res1
);
4623 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4625 if (res2
!= 0) return (res2
);
4633 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4634 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4641 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4642 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4648 int sort_by_salt_buf (const void *v1
, const void *v2
)
4650 const pot_t
*p1
= (const pot_t
*) v1
;
4651 const pot_t
*p2
= (const pot_t
*) v2
;
4653 const hash_t
*h1
= &p1
->hash
;
4654 const hash_t
*h2
= &p2
->hash
;
4656 const salt_t
*s1
= h1
->salt
;
4657 const salt_t
*s2
= h2
->salt
;
4663 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4664 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4670 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4672 const hash_t
*h1
= (const hash_t
*) v1
;
4673 const hash_t
*h2
= (const hash_t
*) v2
;
4675 const salt_t
*s1
= h1
->salt
;
4676 const salt_t
*s2
= h2
->salt
;
4678 // testphase: this should work
4683 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4684 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4687 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4688 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4689 if (s1->salt_len > s2->salt_len) return ( 1);
4690 if (s1->salt_len < s2->salt_len) return (-1);
4692 uint n = s1->salt_len;
4696 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4697 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4704 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4706 const hash_t
*h1
= (const hash_t
*) v1
;
4707 const hash_t
*h2
= (const hash_t
*) v2
;
4709 const salt_t
*s1
= h1
->salt
;
4710 const salt_t
*s2
= h2
->salt
;
4712 // 16 - 2 (since last 2 uints contain the digest)
4717 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4718 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4724 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4726 const hash_t
*h1
= (const hash_t
*) v1
;
4727 const hash_t
*h2
= (const hash_t
*) v2
;
4729 const void *d1
= h1
->digest
;
4730 const void *d2
= h2
->digest
;
4732 return data
.sort_by_digest (d1
, d2
);
4735 int sort_by_hash (const void *v1
, const void *v2
)
4737 const hash_t
*h1
= (const hash_t
*) v1
;
4738 const hash_t
*h2
= (const hash_t
*) v2
;
4742 const salt_t
*s1
= h1
->salt
;
4743 const salt_t
*s2
= h2
->salt
;
4745 int res
= sort_by_salt (s1
, s2
);
4747 if (res
!= 0) return (res
);
4750 const void *d1
= h1
->digest
;
4751 const void *d2
= h2
->digest
;
4753 return data
.sort_by_digest (d1
, d2
);
4756 int sort_by_pot (const void *v1
, const void *v2
)
4758 const pot_t
*p1
= (const pot_t
*) v1
;
4759 const pot_t
*p2
= (const pot_t
*) v2
;
4761 const hash_t
*h1
= &p1
->hash
;
4762 const hash_t
*h2
= &p2
->hash
;
4764 return sort_by_hash (h1
, h2
);
4767 int sort_by_mtime (const void *p1
, const void *p2
)
4769 const char **f1
= (const char **) p1
;
4770 const char **f2
= (const char **) p2
;
4772 struct stat s1
; stat (*f1
, &s1
);
4773 struct stat s2
; stat (*f2
, &s2
);
4775 return s2
.st_mtime
- s1
.st_mtime
;
4778 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4780 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4781 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4783 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4786 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4788 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4789 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4791 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4794 int sort_by_stringptr (const void *p1
, const void *p2
)
4796 const char **s1
= (const char **) p1
;
4797 const char **s2
= (const char **) p2
;
4799 return strcmp (*s1
, *s2
);
4802 int sort_by_dictstat (const void *s1
, const void *s2
)
4804 dictstat_t
*d1
= (dictstat_t
*) s1
;
4805 dictstat_t
*d2
= (dictstat_t
*) s2
;
4808 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4810 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4813 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4816 int sort_by_bitmap (const void *p1
, const void *p2
)
4818 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4819 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4821 return b1
->collisions
- b2
->collisions
;
4824 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4826 const u32
*d1
= (const u32
*) v1
;
4827 const u32
*d2
= (const u32
*) v2
;
4833 if (d1
[n
] > d2
[n
]) return ( 1);
4834 if (d1
[n
] < d2
[n
]) return (-1);
4840 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4842 const u32
*d1
= (const u32
*) v1
;
4843 const u32
*d2
= (const u32
*) v2
;
4849 if (d1
[n
] > d2
[n
]) return ( 1);
4850 if (d1
[n
] < d2
[n
]) return (-1);
4856 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4858 const u32
*d1
= (const u32
*) v1
;
4859 const u32
*d2
= (const u32
*) v2
;
4865 if (d1
[n
] > d2
[n
]) return ( 1);
4866 if (d1
[n
] < d2
[n
]) return (-1);
4872 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4874 const u32
*d1
= (const u32
*) v1
;
4875 const u32
*d2
= (const u32
*) v2
;
4881 if (d1
[n
] > d2
[n
]) return ( 1);
4882 if (d1
[n
] < d2
[n
]) return (-1);
4888 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4890 const u32
*d1
= (const u32
*) v1
;
4891 const u32
*d2
= (const u32
*) v2
;
4897 if (d1
[n
] > d2
[n
]) return ( 1);
4898 if (d1
[n
] < d2
[n
]) return (-1);
4904 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4906 const u32
*d1
= (const u32
*) v1
;
4907 const u32
*d2
= (const u32
*) v2
;
4913 if (d1
[n
] > d2
[n
]) return ( 1);
4914 if (d1
[n
] < d2
[n
]) return (-1);
4920 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4922 const u32
*d1
= (const u32
*) v1
;
4923 const u32
*d2
= (const u32
*) v2
;
4929 if (d1
[n
] > d2
[n
]) return ( 1);
4930 if (d1
[n
] < d2
[n
]) return (-1);
4936 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4938 const u32
*d1
= (const u32
*) v1
;
4939 const u32
*d2
= (const u32
*) v2
;
4945 if (d1
[n
] > d2
[n
]) return ( 1);
4946 if (d1
[n
] < d2
[n
]) return (-1);
4952 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4954 const u64
*d1
= (const u64
*) v1
;
4955 const u64
*d2
= (const u64
*) v2
;
4961 if (d1
[n
] > d2
[n
]) return ( 1);
4962 if (d1
[n
] < d2
[n
]) return (-1);
4968 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4970 const u64
*d1
= (const u64
*) v1
;
4971 const u64
*d2
= (const u64
*) v2
;
4977 if (d1
[n
] > d2
[n
]) return ( 1);
4978 if (d1
[n
] < d2
[n
]) return (-1);
4984 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4986 const u64
*d1
= (const u64
*) v1
;
4987 const u64
*d2
= (const u64
*) v2
;
4993 if (d1
[n
] > d2
[n
]) return ( 1);
4994 if (d1
[n
] < d2
[n
]) return (-1);
5000 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
5002 const u32
*d1
= (const u32
*) v1
;
5003 const u32
*d2
= (const u32
*) v2
;
5005 const uint dgst_pos0
= data
.dgst_pos0
;
5006 const uint dgst_pos1
= data
.dgst_pos1
;
5007 const uint dgst_pos2
= data
.dgst_pos2
;
5008 const uint dgst_pos3
= data
.dgst_pos3
;
5010 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
5011 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
5012 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
5013 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5014 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5015 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5016 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5017 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5022 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5024 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5025 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5027 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5029 if (res1
!= 0) return (res1
);
5034 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5036 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5037 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5039 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5041 if (res1
!= 0) return (res1
);
5043 const int res2
= t1
->attack_mode
5046 if (res2
!= 0) return (res2
);
5048 const int res3
= t1
->hash_type
5051 if (res3
!= 0) return (res3
);
5056 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
)
5058 uint outfile_autohex
= data
.outfile_autohex
;
5060 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5062 FILE *debug_fp
= NULL
;
5064 if (debug_file
!= NULL
)
5066 debug_fp
= fopen (debug_file
, "ab");
5068 lock_file (debug_fp
);
5075 if (debug_fp
== NULL
)
5077 log_info ("WARNING: Could not open debug-file for writing");
5081 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5083 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5085 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5088 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5090 if (debug_mode
== 4)
5092 fputc (':', debug_fp
);
5094 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5097 fputc ('\n', debug_fp
);
5099 if (debug_file
!= NULL
) fclose (debug_fp
);
5103 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5105 int needs_hexify
= 0;
5107 if (outfile_autohex
== 1)
5109 for (uint i
= 0; i
< plain_len
; i
++)
5111 if (plain_ptr
[i
] < 0x20)
5118 if (plain_ptr
[i
] > 0x7f)
5127 if (needs_hexify
== 1)
5129 fprintf (fp
, "$HEX[");
5131 for (uint i
= 0; i
< plain_len
; i
++)
5133 fprintf (fp
, "%02x", plain_ptr
[i
]);
5140 fwrite (plain_ptr
, plain_len
, 1, fp
);
5144 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
)
5146 uint outfile_format
= data
.outfile_format
;
5148 char separator
= data
.separator
;
5150 if (outfile_format
& OUTFILE_FMT_HASH
)
5152 fprintf (out_fp
, "%s", out_buf
);
5154 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5156 fputc (separator
, out_fp
);
5159 else if (data
.username
)
5161 if (username
!= NULL
)
5163 for (uint i
= 0; i
< user_len
; i
++)
5165 fprintf (out_fp
, "%c", username
[i
]);
5168 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5170 fputc (separator
, out_fp
);
5175 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5177 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5179 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5181 fputc (separator
, out_fp
);
5185 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5187 for (uint i
= 0; i
< plain_len
; i
++)
5189 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5192 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5194 fputc (separator
, out_fp
);
5198 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5201 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5206 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5208 fprintf (out_fp
, "%llu", crackpos
);
5213 fputc ('\n', out_fp
);
5216 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
)
5220 pot_key
.hash
.salt
= hashes_buf
->salt
;
5221 pot_key
.hash
.digest
= hashes_buf
->digest
;
5223 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5229 input_buf
[input_len
] = 0;
5232 unsigned char *username
= NULL
;
5237 user_t
*user
= hashes_buf
->hash_info
->user
;
5241 username
= (unsigned char *) (user
->user_name
);
5243 user_len
= user
->user_len
;
5247 // do output the line
5248 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5252 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5253 #define LM_MASKED_PLAIN "[notfound]"
5255 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
)
5261 pot_left_key
.hash
.salt
= hash_left
->salt
;
5262 pot_left_key
.hash
.digest
= hash_left
->digest
;
5264 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5268 uint weak_hash_found
= 0;
5270 pot_t pot_right_key
;
5272 pot_right_key
.hash
.salt
= hash_right
->salt
;
5273 pot_right_key
.hash
.digest
= hash_right
->digest
;
5275 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5277 if (pot_right_ptr
== NULL
)
5279 // special case, if "weak hash"
5281 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5283 weak_hash_found
= 1;
5285 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5287 // in theory this is not needed, but we are paranoia:
5289 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5290 pot_right_ptr
->plain_len
= 0;
5294 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5296 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
5301 // at least one half was found:
5305 input_buf
[input_len
] = 0;
5309 unsigned char *username
= NULL
;
5314 user_t
*user
= hash_left
->hash_info
->user
;
5318 username
= (unsigned char *) (user
->user_name
);
5320 user_len
= user
->user_len
;
5324 // mask the part which was not found
5326 uint left_part_masked
= 0;
5327 uint right_part_masked
= 0;
5329 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5331 if (pot_left_ptr
== NULL
)
5333 left_part_masked
= 1;
5335 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5337 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5339 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5340 pot_left_ptr
->plain_len
= mask_plain_len
;
5343 if (pot_right_ptr
== NULL
)
5345 right_part_masked
= 1;
5347 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5349 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5351 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5352 pot_right_ptr
->plain_len
= mask_plain_len
;
5355 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5359 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5361 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5363 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5365 // do output the line
5367 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5369 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5371 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5372 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5375 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
)
5379 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5381 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5383 if (pot_ptr
== NULL
)
5387 input_buf
[input_len
] = 0;
5389 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5393 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
)
5399 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5401 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5405 pot_t pot_right_key
;
5407 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5409 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5411 uint weak_hash_found
= 0;
5413 if (pot_right_ptr
== NULL
)
5415 // special case, if "weak hash"
5417 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5419 weak_hash_found
= 1;
5421 // we just need that pot_right_ptr is not a NULL pointer
5423 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5427 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5429 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5434 // ... at least one part was not cracked
5438 input_buf
[input_len
] = 0;
5440 // only show the hash part which is still not cracked
5442 uint user_len
= input_len
- 32;
5444 char *hash_output
= (char *) mymalloc (33);
5446 memcpy (hash_output
, input_buf
, input_len
);
5448 if (pot_left_ptr
!= NULL
)
5450 // only show right part (because left part was already found)
5452 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5454 hash_output
[user_len
+ 16] = 0;
5457 if (pot_right_ptr
!= NULL
)
5459 // only show left part (because right part was already found)
5461 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5463 hash_output
[user_len
+ 16] = 0;
5466 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5468 myfree (hash_output
);
5470 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5473 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5475 uint opencl_platforms_filter
= 0;
5477 if (opencl_platforms
)
5479 char *platforms
= strdup (opencl_platforms
);
5481 char *next
= strtok (platforms
, ",");
5485 int platform
= atoi (next
);
5487 if (platform
< 1 || platform
> 32)
5489 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5494 opencl_platforms_filter
|= 1 << (platform
- 1);
5496 } while ((next
= strtok (NULL
, ",")) != NULL
);
5502 opencl_platforms_filter
= -1;
5505 return opencl_platforms_filter
;
5508 u32
setup_devices_filter (char *opencl_devices
)
5510 u32 devices_filter
= 0;
5514 char *devices
= strdup (opencl_devices
);
5516 char *next
= strtok (devices
, ",");
5520 int device_id
= atoi (next
);
5522 if (device_id
< 1 || device_id
> 32)
5524 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5529 devices_filter
|= 1 << (device_id
- 1);
5531 } while ((next
= strtok (NULL
, ",")) != NULL
);
5537 devices_filter
= -1;
5540 return devices_filter
;
5543 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5545 cl_device_type device_types_filter
= 0;
5547 if (opencl_device_types
)
5549 char *device_types
= strdup (opencl_device_types
);
5551 char *next
= strtok (device_types
, ",");
5555 int device_type
= atoi (next
);
5557 if (device_type
< 1 || device_type
> 3)
5559 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5564 device_types_filter
|= 1 << device_type
;
5566 } while ((next
= strtok (NULL
, ",")) != NULL
);
5568 free (device_types
);
5572 // Do not use CPU by default, this often reduces GPU performance because
5573 // the CPU is too busy to handle GPU synchronization
5575 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5578 return device_types_filter
;
5581 u32
get_random_num (const u32 min
, const u32 max
)
5583 if (min
== max
) return (min
);
5585 return ((rand () % (max
- min
)) + min
);
5588 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5590 u32 quotient
= dividend
/ divisor
;
5592 if (dividend
% divisor
) quotient
++;
5597 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5599 u64 quotient
= dividend
/ divisor
;
5601 if (dividend
% divisor
) quotient
++;
5606 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5608 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5609 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5611 if (tm
->tm_year
- 70)
5613 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5614 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5616 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5618 else if (tm
->tm_yday
)
5620 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5621 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5623 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5625 else if (tm
->tm_hour
)
5627 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5628 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5630 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5632 else if (tm
->tm_min
)
5634 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5635 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5637 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5641 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5643 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5647 void format_speed_display (float val
, char *buf
, size_t len
)
5658 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5669 /* generate output */
5673 snprintf (buf
, len
- 1, "%.0f ", val
);
5677 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5681 void lowercase (u8
*buf
, int len
)
5683 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5686 void uppercase (u8
*buf
, int len
)
5688 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5691 int fgetl (FILE *fp
, char *line_buf
)
5697 const int c
= fgetc (fp
);
5699 if (c
== EOF
) break;
5701 line_buf
[line_len
] = (char) c
;
5705 if (line_len
== HCBUFSIZ
) line_len
--;
5707 if (c
== '\n') break;
5710 if (line_len
== 0) return 0;
5712 if (line_buf
[line_len
- 1] == '\n')
5716 line_buf
[line_len
] = 0;
5719 if (line_len
== 0) return 0;
5721 if (line_buf
[line_len
- 1] == '\r')
5725 line_buf
[line_len
] = 0;
5731 int in_superchop (char *buf
)
5733 int len
= strlen (buf
);
5737 if (buf
[len
- 1] == '\n')
5744 if (buf
[len
- 1] == '\r')
5759 char **scan_directory (const char *path
)
5761 char *tmp_path
= mystrdup (path
);
5763 size_t tmp_path_len
= strlen (tmp_path
);
5765 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5767 tmp_path
[tmp_path_len
- 1] = 0;
5769 tmp_path_len
= strlen (tmp_path
);
5772 char **files
= NULL
;
5778 if ((d
= opendir (tmp_path
)) != NULL
)
5784 memset (&e
, 0, sizeof (e
));
5785 struct dirent
*de
= NULL
;
5787 if (readdir_r (d
, &e
, &de
) != 0)
5789 log_error ("ERROR: readdir_r() failed");
5794 if (de
== NULL
) break;
5798 while ((de
= readdir (d
)) != NULL
)
5801 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5803 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5805 char *path_file
= (char *) mymalloc (path_size
+ 1);
5807 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5809 path_file
[path_size
] = 0;
5813 if ((d_test
= opendir (path_file
)) != NULL
)
5821 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5825 files
[num_files
- 1] = path_file
;
5831 else if (errno
== ENOTDIR
)
5833 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5837 files
[num_files
- 1] = mystrdup (path
);
5840 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5844 files
[num_files
- 1] = NULL
;
5851 int count_dictionaries (char **dictionary_files
)
5853 if (dictionary_files
== NULL
) return 0;
5857 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5865 char *stroptitype (const uint opti_type
)
5869 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5870 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5871 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5872 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5873 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5874 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5875 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5876 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5877 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5878 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5879 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5880 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5881 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5882 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5883 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5884 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5885 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5886 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5887 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5893 char *strparser (const uint parser_status
)
5895 switch (parser_status
)
5897 case PARSER_OK
: return ((char *) PA_000
); break;
5898 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5899 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5900 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5901 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5902 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5903 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5904 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5905 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5906 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5907 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5908 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5909 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5910 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5911 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5912 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5913 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5916 return ((char *) PA_255
);
5919 char *strhashtype (const uint hash_mode
)
5923 case 0: return ((char *) HT_00000
); break;
5924 case 10: return ((char *) HT_00010
); break;
5925 case 11: return ((char *) HT_00011
); break;
5926 case 12: return ((char *) HT_00012
); break;
5927 case 20: return ((char *) HT_00020
); break;
5928 case 21: return ((char *) HT_00021
); break;
5929 case 22: return ((char *) HT_00022
); break;
5930 case 23: return ((char *) HT_00023
); break;
5931 case 30: return ((char *) HT_00030
); break;
5932 case 40: return ((char *) HT_00040
); break;
5933 case 50: return ((char *) HT_00050
); break;
5934 case 60: return ((char *) HT_00060
); break;
5935 case 100: return ((char *) HT_00100
); break;
5936 case 101: return ((char *) HT_00101
); break;
5937 case 110: return ((char *) HT_00110
); break;
5938 case 111: return ((char *) HT_00111
); break;
5939 case 112: return ((char *) HT_00112
); break;
5940 case 120: return ((char *) HT_00120
); break;
5941 case 121: return ((char *) HT_00121
); break;
5942 case 122: return ((char *) HT_00122
); break;
5943 case 124: return ((char *) HT_00124
); break;
5944 case 125: return ((char *) HT_00125
); break;
5945 case 130: return ((char *) HT_00130
); break;
5946 case 131: return ((char *) HT_00131
); break;
5947 case 132: return ((char *) HT_00132
); break;
5948 case 133: return ((char *) HT_00133
); break;
5949 case 140: return ((char *) HT_00140
); break;
5950 case 141: return ((char *) HT_00141
); break;
5951 case 150: return ((char *) HT_00150
); break;
5952 case 160: return ((char *) HT_00160
); break;
5953 case 200: return ((char *) HT_00200
); break;
5954 case 300: return ((char *) HT_00300
); break;
5955 case 400: return ((char *) HT_00400
); break;
5956 case 500: return ((char *) HT_00500
); break;
5957 case 501: return ((char *) HT_00501
); break;
5958 case 900: return ((char *) HT_00900
); break;
5959 case 910: return ((char *) HT_00910
); break;
5960 case 1000: return ((char *) HT_01000
); break;
5961 case 1100: return ((char *) HT_01100
); break;
5962 case 1400: return ((char *) HT_01400
); break;
5963 case 1410: return ((char *) HT_01410
); break;
5964 case 1420: return ((char *) HT_01420
); break;
5965 case 1421: return ((char *) HT_01421
); break;
5966 case 1430: return ((char *) HT_01430
); break;
5967 case 1440: return ((char *) HT_01440
); break;
5968 case 1441: return ((char *) HT_01441
); break;
5969 case 1450: return ((char *) HT_01450
); break;
5970 case 1460: return ((char *) HT_01460
); break;
5971 case 1500: return ((char *) HT_01500
); break;
5972 case 1600: return ((char *) HT_01600
); break;
5973 case 1700: return ((char *) HT_01700
); break;
5974 case 1710: return ((char *) HT_01710
); break;
5975 case 1711: return ((char *) HT_01711
); break;
5976 case 1720: return ((char *) HT_01720
); break;
5977 case 1722: return ((char *) HT_01722
); break;
5978 case 1730: return ((char *) HT_01730
); break;
5979 case 1731: return ((char *) HT_01731
); break;
5980 case 1740: return ((char *) HT_01740
); break;
5981 case 1750: return ((char *) HT_01750
); break;
5982 case 1760: return ((char *) HT_01760
); break;
5983 case 1800: return ((char *) HT_01800
); break;
5984 case 2100: return ((char *) HT_02100
); break;
5985 case 2400: return ((char *) HT_02400
); break;
5986 case 2410: return ((char *) HT_02410
); break;
5987 case 2500: return ((char *) HT_02500
); break;
5988 case 2600: return ((char *) HT_02600
); break;
5989 case 2611: return ((char *) HT_02611
); break;
5990 case 2612: return ((char *) HT_02612
); break;
5991 case 2711: return ((char *) HT_02711
); break;
5992 case 2811: return ((char *) HT_02811
); break;
5993 case 3000: return ((char *) HT_03000
); break;
5994 case 3100: return ((char *) HT_03100
); break;
5995 case 3200: return ((char *) HT_03200
); break;
5996 case 3710: return ((char *) HT_03710
); break;
5997 case 3711: return ((char *) HT_03711
); break;
5998 case 3800: return ((char *) HT_03800
); break;
5999 case 4300: return ((char *) HT_04300
); break;
6000 case 4400: return ((char *) HT_04400
); break;
6001 case 4500: return ((char *) HT_04500
); break;
6002 case 4700: return ((char *) HT_04700
); break;
6003 case 4800: return ((char *) HT_04800
); break;
6004 case 4900: return ((char *) HT_04900
); break;
6005 case 5000: return ((char *) HT_05000
); break;
6006 case 5100: return ((char *) HT_05100
); break;
6007 case 5200: return ((char *) HT_05200
); break;
6008 case 5300: return ((char *) HT_05300
); break;
6009 case 5400: return ((char *) HT_05400
); break;
6010 case 5500: return ((char *) HT_05500
); break;
6011 case 5600: return ((char *) HT_05600
); break;
6012 case 5700: return ((char *) HT_05700
); break;
6013 case 5800: return ((char *) HT_05800
); break;
6014 case 6000: return ((char *) HT_06000
); break;
6015 case 6100: return ((char *) HT_06100
); break;
6016 case 6211: return ((char *) HT_06211
); break;
6017 case 6212: return ((char *) HT_06212
); break;
6018 case 6213: return ((char *) HT_06213
); break;
6019 case 6221: return ((char *) HT_06221
); break;
6020 case 6222: return ((char *) HT_06222
); break;
6021 case 6223: return ((char *) HT_06223
); break;
6022 case 6231: return ((char *) HT_06231
); break;
6023 case 6232: return ((char *) HT_06232
); break;
6024 case 6233: return ((char *) HT_06233
); break;
6025 case 6241: return ((char *) HT_06241
); break;
6026 case 6242: return ((char *) HT_06242
); break;
6027 case 6243: return ((char *) HT_06243
); break;
6028 case 6300: return ((char *) HT_06300
); break;
6029 case 6400: return ((char *) HT_06400
); break;
6030 case 6500: return ((char *) HT_06500
); break;
6031 case 6600: return ((char *) HT_06600
); break;
6032 case 6700: return ((char *) HT_06700
); break;
6033 case 6800: return ((char *) HT_06800
); break;
6034 case 6900: return ((char *) HT_06900
); break;
6035 case 7100: return ((char *) HT_07100
); break;
6036 case 7200: return ((char *) HT_07200
); break;
6037 case 7300: return ((char *) HT_07300
); break;
6038 case 7400: return ((char *) HT_07400
); break;
6039 case 7500: return ((char *) HT_07500
); break;
6040 case 7600: return ((char *) HT_07600
); break;
6041 case 7700: return ((char *) HT_07700
); break;
6042 case 7800: return ((char *) HT_07800
); break;
6043 case 7900: return ((char *) HT_07900
); break;
6044 case 8000: return ((char *) HT_08000
); break;
6045 case 8100: return ((char *) HT_08100
); break;
6046 case 8200: return ((char *) HT_08200
); break;
6047 case 8300: return ((char *) HT_08300
); break;
6048 case 8400: return ((char *) HT_08400
); break;
6049 case 8500: return ((char *) HT_08500
); break;
6050 case 8600: return ((char *) HT_08600
); break;
6051 case 8700: return ((char *) HT_08700
); break;
6052 case 8800: return ((char *) HT_08800
); break;
6053 case 8900: return ((char *) HT_08900
); break;
6054 case 9000: return ((char *) HT_09000
); break;
6055 case 9100: return ((char *) HT_09100
); break;
6056 case 9200: return ((char *) HT_09200
); break;
6057 case 9300: return ((char *) HT_09300
); break;
6058 case 9400: return ((char *) HT_09400
); break;
6059 case 9500: return ((char *) HT_09500
); break;
6060 case 9600: return ((char *) HT_09600
); break;
6061 case 9700: return ((char *) HT_09700
); break;
6062 case 9710: return ((char *) HT_09710
); break;
6063 case 9720: return ((char *) HT_09720
); break;
6064 case 9800: return ((char *) HT_09800
); break;
6065 case 9810: return ((char *) HT_09810
); break;
6066 case 9820: return ((char *) HT_09820
); break;
6067 case 9900: return ((char *) HT_09900
); break;
6068 case 10000: return ((char *) HT_10000
); break;
6069 case 10100: return ((char *) HT_10100
); break;
6070 case 10200: return ((char *) HT_10200
); break;
6071 case 10300: return ((char *) HT_10300
); break;
6072 case 10400: return ((char *) HT_10400
); break;
6073 case 10410: return ((char *) HT_10410
); break;
6074 case 10420: return ((char *) HT_10420
); break;
6075 case 10500: return ((char *) HT_10500
); break;
6076 case 10600: return ((char *) HT_10600
); break;
6077 case 10700: return ((char *) HT_10700
); break;
6078 case 10800: return ((char *) HT_10800
); break;
6079 case 10900: return ((char *) HT_10900
); break;
6080 case 11000: return ((char *) HT_11000
); break;
6081 case 11100: return ((char *) HT_11100
); break;
6082 case 11200: return ((char *) HT_11200
); break;
6083 case 11300: return ((char *) HT_11300
); break;
6084 case 11400: return ((char *) HT_11400
); break;
6085 case 11500: return ((char *) HT_11500
); break;
6086 case 11600: return ((char *) HT_11600
); break;
6087 case 11700: return ((char *) HT_11700
); break;
6088 case 11800: return ((char *) HT_11800
); break;
6089 case 11900: return ((char *) HT_11900
); break;
6090 case 12000: return ((char *) HT_12000
); break;
6091 case 12100: return ((char *) HT_12100
); break;
6092 case 12200: return ((char *) HT_12200
); break;
6093 case 12300: return ((char *) HT_12300
); break;
6094 case 12400: return ((char *) HT_12400
); break;
6095 case 12500: return ((char *) HT_12500
); break;
6096 case 12600: return ((char *) HT_12600
); break;
6097 case 12700: return ((char *) HT_12700
); break;
6098 case 12800: return ((char *) HT_12800
); break;
6099 case 12900: return ((char *) HT_12900
); break;
6100 case 13000: return ((char *) HT_13000
); break;
6101 case 13100: return ((char *) HT_13100
); break;
6102 case 13200: return ((char *) HT_13200
); break;
6103 case 13300: return ((char *) HT_13300
); break;
6104 case 13400: return ((char *) HT_13400
); break;
6105 case 13500: return ((char *) HT_13500
); break;
6106 case 13600: return ((char *) HT_13600
); break;
6107 case 13711: return ((char *) HT_13711
); break;
6108 case 13712: return ((char *) HT_13712
); break;
6109 case 13713: return ((char *) HT_13713
); break;
6110 case 13721: return ((char *) HT_13721
); break;
6111 case 13722: return ((char *) HT_13722
); break;
6112 case 13723: return ((char *) HT_13723
); break;
6113 case 13731: return ((char *) HT_13731
); break;
6114 case 13732: return ((char *) HT_13732
); break;
6115 case 13733: return ((char *) HT_13733
); break;
6116 case 13741: return ((char *) HT_13741
); break;
6117 case 13742: return ((char *) HT_13742
); break;
6118 case 13743: return ((char *) HT_13743
); break;
6119 case 13751: return ((char *) HT_13751
); break;
6120 case 13752: return ((char *) HT_13752
); break;
6121 case 13753: return ((char *) HT_13753
); break;
6122 case 13761: return ((char *) HT_13761
); break;
6123 case 13762: return ((char *) HT_13762
); break;
6124 case 13763: return ((char *) HT_13763
); break;
6125 case 13800: return ((char *) HT_13800
); break;
6128 return ((char *) "Unknown");
6131 char *strstatus (const uint devices_status
)
6133 switch (devices_status
)
6135 case STATUS_INIT
: return ((char *) ST_0000
); break;
6136 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6137 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6138 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6139 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6140 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6141 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6142 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6143 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6144 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6145 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6148 return ((char *) "Unknown");
6151 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6153 uint hash_type
= data
.hash_type
;
6154 uint hash_mode
= data
.hash_mode
;
6155 uint salt_type
= data
.salt_type
;
6156 uint opts_type
= data
.opts_type
;
6157 uint opti_type
= data
.opti_type
;
6158 uint dgst_size
= data
.dgst_size
;
6160 char *hashfile
= data
.hashfile
;
6164 uint digest_buf
[64] = { 0 };
6166 u64
*digest_buf64
= (u64
*) digest_buf
;
6168 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6170 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6172 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6178 case HASH_TYPE_DESCRYPT
:
6179 FP (digest_buf
[1], digest_buf
[0], tt
);
6182 case HASH_TYPE_DESRACF
:
6183 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6184 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6186 FP (digest_buf
[1], digest_buf
[0], tt
);
6190 FP (digest_buf
[1], digest_buf
[0], tt
);
6193 case HASH_TYPE_NETNTLM
:
6194 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6195 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6196 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6197 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6199 FP (digest_buf
[1], digest_buf
[0], tt
);
6200 FP (digest_buf
[3], digest_buf
[2], tt
);
6203 case HASH_TYPE_BSDICRYPT
:
6204 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6205 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6207 FP (digest_buf
[1], digest_buf
[0], tt
);
6212 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6217 digest_buf
[0] += MD4M_A
;
6218 digest_buf
[1] += MD4M_B
;
6219 digest_buf
[2] += MD4M_C
;
6220 digest_buf
[3] += MD4M_D
;
6224 digest_buf
[0] += MD5M_A
;
6225 digest_buf
[1] += MD5M_B
;
6226 digest_buf
[2] += MD5M_C
;
6227 digest_buf
[3] += MD5M_D
;
6230 case HASH_TYPE_SHA1
:
6231 digest_buf
[0] += SHA1M_A
;
6232 digest_buf
[1] += SHA1M_B
;
6233 digest_buf
[2] += SHA1M_C
;
6234 digest_buf
[3] += SHA1M_D
;
6235 digest_buf
[4] += SHA1M_E
;
6238 case HASH_TYPE_SHA256
:
6239 digest_buf
[0] += SHA256M_A
;
6240 digest_buf
[1] += SHA256M_B
;
6241 digest_buf
[2] += SHA256M_C
;
6242 digest_buf
[3] += SHA256M_D
;
6243 digest_buf
[4] += SHA256M_E
;
6244 digest_buf
[5] += SHA256M_F
;
6245 digest_buf
[6] += SHA256M_G
;
6246 digest_buf
[7] += SHA256M_H
;
6249 case HASH_TYPE_SHA384
:
6250 digest_buf64
[0] += SHA384M_A
;
6251 digest_buf64
[1] += SHA384M_B
;
6252 digest_buf64
[2] += SHA384M_C
;
6253 digest_buf64
[3] += SHA384M_D
;
6254 digest_buf64
[4] += SHA384M_E
;
6255 digest_buf64
[5] += SHA384M_F
;
6256 digest_buf64
[6] += 0;
6257 digest_buf64
[7] += 0;
6260 case HASH_TYPE_SHA512
:
6261 digest_buf64
[0] += SHA512M_A
;
6262 digest_buf64
[1] += SHA512M_B
;
6263 digest_buf64
[2] += SHA512M_C
;
6264 digest_buf64
[3] += SHA512M_D
;
6265 digest_buf64
[4] += SHA512M_E
;
6266 digest_buf64
[5] += SHA512M_F
;
6267 digest_buf64
[6] += SHA512M_G
;
6268 digest_buf64
[7] += SHA512M_H
;
6273 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6275 if (dgst_size
== DGST_SIZE_4_2
)
6277 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6279 else if (dgst_size
== DGST_SIZE_4_4
)
6281 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6283 else if (dgst_size
== DGST_SIZE_4_5
)
6285 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6287 else if (dgst_size
== DGST_SIZE_4_6
)
6289 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6291 else if (dgst_size
== DGST_SIZE_4_8
)
6293 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6295 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6297 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6299 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6301 else if (hash_type
== HASH_TYPE_SHA384
)
6303 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6305 else if (hash_type
== HASH_TYPE_SHA512
)
6307 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6309 else if (hash_type
== HASH_TYPE_GOST
)
6311 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6314 else if (dgst_size
== DGST_SIZE_4_64
)
6316 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6318 else if (dgst_size
== DGST_SIZE_8_25
)
6320 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6324 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6325 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6326 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6332 memset (&salt
, 0, sizeof (salt_t
));
6334 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6336 char *ptr
= (char *) salt
.salt_buf
;
6338 uint len
= salt
.salt_len
;
6340 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6346 case HASH_TYPE_NETNTLM
:
6348 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6349 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6351 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6357 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6359 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6367 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6369 uint max
= salt
.salt_len
/ 4;
6373 for (uint i
= 0; i
< max
; i
++)
6375 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6379 if (opts_type
& OPTS_TYPE_ST_HEX
)
6381 char tmp
[64] = { 0 };
6383 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6385 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6390 memcpy (ptr
, tmp
, len
);
6393 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6395 memset (ptr
+ len
, 0, memset_size
);
6397 salt
.salt_len
= len
;
6401 // some modes require special encoding
6404 uint out_buf_plain
[256] = { 0 };
6405 uint out_buf_salt
[256] = { 0 };
6407 char tmp_buf
[1024] = { 0 };
6409 char *ptr_plain
= (char *) out_buf_plain
;
6410 char *ptr_salt
= (char *) out_buf_salt
;
6412 if (hash_mode
== 22)
6414 char username
[30] = { 0 };
6416 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6418 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6420 u16
*ptr
= (u16
*) digest_buf
;
6422 tmp_buf
[ 0] = sig
[0];
6423 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6424 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6425 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6426 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6427 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6428 tmp_buf
[ 6] = sig
[1];
6429 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6430 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6431 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6432 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6433 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6434 tmp_buf
[12] = sig
[2];
6435 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6436 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6437 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6438 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6439 tmp_buf
[17] = sig
[3];
6440 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6441 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6442 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6443 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6444 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6445 tmp_buf
[23] = sig
[4];
6446 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6447 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6448 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6449 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6450 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6451 tmp_buf
[29] = sig
[5];
6453 snprintf (out_buf
, len
-1, "%s:%s",
6457 else if (hash_mode
== 23)
6459 // do not show the skyper part in output
6461 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6463 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6465 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6472 else if (hash_mode
== 101)
6474 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6476 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6477 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6478 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6479 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6480 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6482 memcpy (tmp_buf
, digest_buf
, 20);
6484 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6486 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6488 else if (hash_mode
== 111)
6490 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6492 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6493 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6494 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6495 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6496 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6498 memcpy (tmp_buf
, digest_buf
, 20);
6499 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6501 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6503 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6505 else if ((hash_mode
== 122) || (hash_mode
== 125))
6507 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6508 (char *) salt
.salt_buf
,
6515 else if (hash_mode
== 124)
6517 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6518 (char *) salt
.salt_buf
,
6525 else if (hash_mode
== 131)
6527 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6528 (char *) salt
.salt_buf
,
6536 else if (hash_mode
== 132)
6538 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6539 (char *) salt
.salt_buf
,
6546 else if (hash_mode
== 133)
6548 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6550 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6551 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6552 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6553 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6554 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6556 memcpy (tmp_buf
, digest_buf
, 20);
6558 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6560 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6562 else if (hash_mode
== 141)
6564 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6566 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6568 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6570 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6572 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6573 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6574 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6575 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6576 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6578 memcpy (tmp_buf
, digest_buf
, 20);
6580 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6584 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6586 else if (hash_mode
== 400)
6588 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6590 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6591 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6592 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6593 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6595 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6597 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6599 else if (hash_mode
== 500)
6601 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6603 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6604 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6605 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6606 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6608 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6610 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6612 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6616 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6619 else if (hash_mode
== 501)
6621 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6623 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6624 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6626 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6628 else if (hash_mode
== 1421)
6630 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6632 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6648 else if (hash_mode
== 1441)
6650 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6652 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6654 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6656 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6658 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6659 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6660 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6661 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6662 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6663 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6664 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6665 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6667 memcpy (tmp_buf
, digest_buf
, 32);
6669 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6673 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6675 else if (hash_mode
== 1500)
6677 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6678 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6679 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6680 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6681 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6683 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6685 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6687 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6688 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6690 memcpy (tmp_buf
, digest_buf
, 8);
6692 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6694 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6698 else if (hash_mode
== 1600)
6700 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6702 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6703 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6704 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6705 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6707 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6709 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6711 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6715 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6718 else if (hash_mode
== 1711)
6720 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6722 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6723 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6724 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6725 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6726 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6727 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6728 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6729 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6731 memcpy (tmp_buf
, digest_buf
, 64);
6732 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6734 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6736 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6738 else if (hash_mode
== 1722)
6740 uint
*ptr
= digest_buf
;
6742 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6743 (unsigned char *) salt
.salt_buf
,
6753 else if (hash_mode
== 1731)
6755 uint
*ptr
= digest_buf
;
6757 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6758 (unsigned char *) salt
.salt_buf
,
6768 else if (hash_mode
== 1800)
6772 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6773 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6774 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6775 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6776 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6777 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6778 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6779 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6781 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6783 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6785 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6789 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6792 else if (hash_mode
== 2100)
6796 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6798 salt
.salt_iter
+ 1);
6800 uint signature_len
= strlen (out_buf
);
6802 pos
+= signature_len
;
6803 len
-= signature_len
;
6805 char *salt_ptr
= (char *) salt
.salt_buf
;
6807 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6809 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6810 byte_swap_32 (digest_buf
[0]),
6811 byte_swap_32 (digest_buf
[1]),
6812 byte_swap_32 (digest_buf
[2]),
6813 byte_swap_32 (digest_buf
[3]));
6815 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6817 memcpy (tmp_buf
, digest_buf
, 16);
6819 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6821 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6822 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6823 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6824 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6826 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6827 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6828 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6829 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6831 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6832 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6833 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6834 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6836 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6837 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6838 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6839 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6841 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6842 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6843 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6844 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6848 else if (hash_mode
== 2500)
6850 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6852 wpa_t
*wpa
= &wpas
[salt_pos
];
6854 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6855 (char *) salt
.salt_buf
,
6869 else if (hash_mode
== 4400)
6871 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6872 byte_swap_32 (digest_buf
[0]),
6873 byte_swap_32 (digest_buf
[1]),
6874 byte_swap_32 (digest_buf
[2]),
6875 byte_swap_32 (digest_buf
[3]));
6877 else if (hash_mode
== 4700)
6879 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6880 byte_swap_32 (digest_buf
[0]),
6881 byte_swap_32 (digest_buf
[1]),
6882 byte_swap_32 (digest_buf
[2]),
6883 byte_swap_32 (digest_buf
[3]),
6884 byte_swap_32 (digest_buf
[4]));
6886 else if (hash_mode
== 4800)
6888 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6890 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6895 byte_swap_32 (salt
.salt_buf
[0]),
6896 byte_swap_32 (salt
.salt_buf
[1]),
6897 byte_swap_32 (salt
.salt_buf
[2]),
6898 byte_swap_32 (salt
.salt_buf
[3]),
6901 else if (hash_mode
== 4900)
6903 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6904 byte_swap_32 (digest_buf
[0]),
6905 byte_swap_32 (digest_buf
[1]),
6906 byte_swap_32 (digest_buf
[2]),
6907 byte_swap_32 (digest_buf
[3]),
6908 byte_swap_32 (digest_buf
[4]));
6910 else if (hash_mode
== 5100)
6912 snprintf (out_buf
, len
-1, "%08x%08x",
6916 else if (hash_mode
== 5200)
6918 snprintf (out_buf
, len
-1, "%s", hashfile
);
6920 else if (hash_mode
== 5300)
6922 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6924 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6926 int buf_len
= len
-1;
6930 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6932 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6934 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6936 snprintf (out_buf
, buf_len
, ":");
6942 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6950 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6952 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6954 if ((i
== 0) || (i
== 5))
6956 snprintf (out_buf
, buf_len
, ":");
6962 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6970 for (uint i
= 0; i
< 4; i
++)
6974 snprintf (out_buf
, buf_len
, ":");
6980 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6986 else if (hash_mode
== 5400)
6988 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6990 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6992 int buf_len
= len
-1;
6996 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6998 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
7000 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
7002 snprintf (out_buf
, buf_len
, ":");
7008 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7016 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7018 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7020 if ((i
== 0) || (i
== 5))
7022 snprintf (out_buf
, buf_len
, ":");
7028 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7036 for (uint i
= 0; i
< 5; i
++)
7040 snprintf (out_buf
, buf_len
, ":");
7046 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7052 else if (hash_mode
== 5500)
7054 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7056 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7058 char user_buf
[64] = { 0 };
7059 char domain_buf
[64] = { 0 };
7060 char srvchall_buf
[1024] = { 0 };
7061 char clichall_buf
[1024] = { 0 };
7063 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7065 char *ptr
= (char *) netntlm
->userdomain_buf
;
7067 user_buf
[i
] = ptr
[j
];
7070 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7072 char *ptr
= (char *) netntlm
->userdomain_buf
;
7074 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7077 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7079 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7081 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7084 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7086 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7088 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7091 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7099 byte_swap_32 (salt
.salt_buf_pc
[0]),
7100 byte_swap_32 (salt
.salt_buf_pc
[1]),
7103 else if (hash_mode
== 5600)
7105 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7107 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7109 char user_buf
[64] = { 0 };
7110 char domain_buf
[64] = { 0 };
7111 char srvchall_buf
[1024] = { 0 };
7112 char clichall_buf
[1024] = { 0 };
7114 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7116 char *ptr
= (char *) netntlm
->userdomain_buf
;
7118 user_buf
[i
] = ptr
[j
];
7121 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7123 char *ptr
= (char *) netntlm
->userdomain_buf
;
7125 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7128 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7130 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7132 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7135 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7137 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7139 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7142 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7152 else if (hash_mode
== 5700)
7154 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7156 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7157 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7158 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7159 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7160 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7161 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7162 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7163 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7165 memcpy (tmp_buf
, digest_buf
, 32);
7167 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7171 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7173 else if (hash_mode
== 5800)
7175 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7176 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7177 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7178 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7179 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7181 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7188 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7190 snprintf (out_buf
, len
-1, "%s", hashfile
);
7192 else if (hash_mode
== 6300)
7194 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7196 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7197 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7198 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7199 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7201 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7203 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7205 else if (hash_mode
== 6400)
7207 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7209 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7211 else if (hash_mode
== 6500)
7213 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7215 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7217 else if (hash_mode
== 6600)
7219 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7221 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7223 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7224 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7226 uint buf_len
= len
- 1;
7228 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7231 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7233 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7238 else if (hash_mode
== 6700)
7240 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7242 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7244 else if (hash_mode
== 6800)
7246 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7248 else if (hash_mode
== 7100)
7250 uint
*ptr
= digest_buf
;
7252 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7254 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7256 uint esalt
[8] = { 0 };
7258 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7259 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7260 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7261 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7262 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7263 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7264 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7265 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7267 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",
7268 SIGNATURE_SHA512OSX
,
7270 esalt
[ 0], esalt
[ 1],
7271 esalt
[ 2], esalt
[ 3],
7272 esalt
[ 4], esalt
[ 5],
7273 esalt
[ 6], esalt
[ 7],
7281 ptr
[15], ptr
[14]);
7283 else if (hash_mode
== 7200)
7285 uint
*ptr
= digest_buf
;
7287 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7289 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7293 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7295 len_used
= strlen (out_buf
);
7297 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7299 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7301 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7304 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",
7312 ptr
[15], ptr
[14]);
7314 else if (hash_mode
== 7300)
7316 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7318 rakp_t
*rakp
= &rakps
[salt_pos
];
7320 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7322 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7325 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7332 else if (hash_mode
== 7400)
7334 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7336 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7337 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7338 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7339 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7340 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7341 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7342 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7343 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7345 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7347 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7349 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7353 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7356 else if (hash_mode
== 7500)
7358 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7360 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7362 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7363 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7365 char data
[128] = { 0 };
7367 char *ptr_data
= data
;
7369 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7371 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7374 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7376 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7381 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7383 (char *) krb5pa
->user
,
7384 (char *) krb5pa
->realm
,
7385 (char *) krb5pa
->salt
,
7388 else if (hash_mode
== 7700)
7390 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7391 (char *) salt
.salt_buf
,
7395 else if (hash_mode
== 7800)
7397 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7398 (char *) salt
.salt_buf
,
7405 else if (hash_mode
== 7900)
7407 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7411 char *tmp
= (char *) salt
.salt_buf_pc
;
7413 ptr_plain
[42] = tmp
[0];
7419 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7421 else if (hash_mode
== 8000)
7423 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7424 (unsigned char *) salt
.salt_buf
,
7434 else if (hash_mode
== 8100)
7436 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7437 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7439 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7440 (unsigned char *) salt
.salt_buf
,
7447 else if (hash_mode
== 8200)
7449 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7451 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7453 char data_buf
[4096] = { 0 };
7455 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7457 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7460 data_buf
[cloudkey
->data_len
* 2] = 0;
7462 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7463 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7464 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7465 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7466 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7467 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7468 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7469 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7471 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7472 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7473 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7474 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7476 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7492 else if (hash_mode
== 8300)
7494 char digest_buf_c
[34] = { 0 };
7496 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7497 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7498 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7499 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7500 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7502 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7504 digest_buf_c
[32] = 0;
7508 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7510 char domain_buf_c
[33] = { 0 };
7512 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7514 for (uint i
= 0; i
< salt_pc_len
; i
++)
7516 const char next
= domain_buf_c
[i
];
7518 domain_buf_c
[i
] = '.';
7523 domain_buf_c
[salt_pc_len
] = 0;
7527 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7529 else if (hash_mode
== 8500)
7531 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7533 else if (hash_mode
== 2612)
7535 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7537 (char *) salt
.salt_buf
,
7543 else if (hash_mode
== 3711)
7545 char *salt_ptr
= (char *) salt
.salt_buf
;
7547 salt_ptr
[salt
.salt_len
- 1] = 0;
7549 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7550 SIGNATURE_MEDIAWIKI_B
,
7557 else if (hash_mode
== 8800)
7559 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7561 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7563 char tmp
[3073] = { 0 };
7565 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7567 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7572 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7573 SIGNATURE_ANDROIDFDE
,
7574 byte_swap_32 (salt
.salt_buf
[0]),
7575 byte_swap_32 (salt
.salt_buf
[1]),
7576 byte_swap_32 (salt
.salt_buf
[2]),
7577 byte_swap_32 (salt
.salt_buf
[3]),
7578 byte_swap_32 (digest_buf
[0]),
7579 byte_swap_32 (digest_buf
[1]),
7580 byte_swap_32 (digest_buf
[2]),
7581 byte_swap_32 (digest_buf
[3]),
7584 else if (hash_mode
== 8900)
7586 uint N
= salt
.scrypt_N
;
7587 uint r
= salt
.scrypt_r
;
7588 uint p
= salt
.scrypt_p
;
7590 char base64_salt
[32] = { 0 };
7592 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7594 memset (tmp_buf
, 0, 46);
7596 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7597 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7598 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7599 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7600 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7601 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7602 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7603 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7604 digest_buf
[8] = 0; // needed for base64_encode ()
7606 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7608 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7616 else if (hash_mode
== 9000)
7618 snprintf (out_buf
, len
-1, "%s", hashfile
);
7620 else if (hash_mode
== 9200)
7624 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7626 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7628 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7632 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7633 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7634 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7635 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7636 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7637 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7638 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7639 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7640 digest_buf
[8] = 0; // needed for base64_encode ()
7642 char tmp_buf
[64] = { 0 };
7644 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7645 tmp_buf
[43] = 0; // cut it here
7649 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7651 else if (hash_mode
== 9300)
7653 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7654 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7655 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7656 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7657 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7658 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7659 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7660 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7661 digest_buf
[8] = 0; // needed for base64_encode ()
7663 char tmp_buf
[64] = { 0 };
7665 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7666 tmp_buf
[43] = 0; // cut it here
7668 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7670 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7672 else if (hash_mode
== 9400)
7674 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7676 office2007_t
*office2007
= &office2007s
[salt_pos
];
7678 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7679 SIGNATURE_OFFICE2007
,
7682 office2007
->keySize
,
7688 office2007
->encryptedVerifier
[0],
7689 office2007
->encryptedVerifier
[1],
7690 office2007
->encryptedVerifier
[2],
7691 office2007
->encryptedVerifier
[3],
7692 office2007
->encryptedVerifierHash
[0],
7693 office2007
->encryptedVerifierHash
[1],
7694 office2007
->encryptedVerifierHash
[2],
7695 office2007
->encryptedVerifierHash
[3],
7696 office2007
->encryptedVerifierHash
[4]);
7698 else if (hash_mode
== 9500)
7700 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7702 office2010_t
*office2010
= &office2010s
[salt_pos
];
7704 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,
7710 office2010
->encryptedVerifier
[0],
7711 office2010
->encryptedVerifier
[1],
7712 office2010
->encryptedVerifier
[2],
7713 office2010
->encryptedVerifier
[3],
7714 office2010
->encryptedVerifierHash
[0],
7715 office2010
->encryptedVerifierHash
[1],
7716 office2010
->encryptedVerifierHash
[2],
7717 office2010
->encryptedVerifierHash
[3],
7718 office2010
->encryptedVerifierHash
[4],
7719 office2010
->encryptedVerifierHash
[5],
7720 office2010
->encryptedVerifierHash
[6],
7721 office2010
->encryptedVerifierHash
[7]);
7723 else if (hash_mode
== 9600)
7725 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7727 office2013_t
*office2013
= &office2013s
[salt_pos
];
7729 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,
7735 office2013
->encryptedVerifier
[0],
7736 office2013
->encryptedVerifier
[1],
7737 office2013
->encryptedVerifier
[2],
7738 office2013
->encryptedVerifier
[3],
7739 office2013
->encryptedVerifierHash
[0],
7740 office2013
->encryptedVerifierHash
[1],
7741 office2013
->encryptedVerifierHash
[2],
7742 office2013
->encryptedVerifierHash
[3],
7743 office2013
->encryptedVerifierHash
[4],
7744 office2013
->encryptedVerifierHash
[5],
7745 office2013
->encryptedVerifierHash
[6],
7746 office2013
->encryptedVerifierHash
[7]);
7748 else if (hash_mode
== 9700)
7750 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7752 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7754 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7755 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7756 byte_swap_32 (salt
.salt_buf
[0]),
7757 byte_swap_32 (salt
.salt_buf
[1]),
7758 byte_swap_32 (salt
.salt_buf
[2]),
7759 byte_swap_32 (salt
.salt_buf
[3]),
7760 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7761 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7762 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7765 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7766 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7767 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7769 else if (hash_mode
== 9710)
7771 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7773 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7775 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7776 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7777 byte_swap_32 (salt
.salt_buf
[0]),
7778 byte_swap_32 (salt
.salt_buf
[1]),
7779 byte_swap_32 (salt
.salt_buf
[2]),
7780 byte_swap_32 (salt
.salt_buf
[3]),
7781 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7782 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7783 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7784 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7785 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7786 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7787 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7788 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7790 else if (hash_mode
== 9720)
7792 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7794 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7796 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7798 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7799 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7800 byte_swap_32 (salt
.salt_buf
[0]),
7801 byte_swap_32 (salt
.salt_buf
[1]),
7802 byte_swap_32 (salt
.salt_buf
[2]),
7803 byte_swap_32 (salt
.salt_buf
[3]),
7804 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7805 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7806 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7807 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7808 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7809 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7810 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7811 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7818 else if (hash_mode
== 9800)
7820 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7822 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7824 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7825 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7830 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7831 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7832 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7833 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7838 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7840 else if (hash_mode
== 9810)
7842 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7844 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7846 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7847 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7852 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7853 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7854 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7855 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7856 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7857 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7858 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7859 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7860 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7862 else if (hash_mode
== 9820)
7864 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7866 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7868 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7870 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7871 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7876 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7877 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7878 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7879 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7880 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7881 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7882 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7883 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7884 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7891 else if (hash_mode
== 10000)
7895 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7897 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7899 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7903 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7904 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7905 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7906 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7907 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7908 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7909 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7910 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7911 digest_buf
[8] = 0; // needed for base64_encode ()
7913 char tmp_buf
[64] = { 0 };
7915 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7919 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7921 else if (hash_mode
== 10100)
7923 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7928 byte_swap_32 (salt
.salt_buf
[0]),
7929 byte_swap_32 (salt
.salt_buf
[1]),
7930 byte_swap_32 (salt
.salt_buf
[2]),
7931 byte_swap_32 (salt
.salt_buf
[3]));
7933 else if (hash_mode
== 10200)
7935 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7937 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7941 char challenge
[100] = { 0 };
7943 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7947 char tmp_buf
[100] = { 0 };
7949 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7950 (char *) cram_md5
->user
,
7956 char response
[100] = { 0 };
7958 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7960 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7962 else if (hash_mode
== 10300)
7964 char tmp_buf
[100] = { 0 };
7966 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7967 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7969 uint tmp_len
= 20 + salt
.salt_len
;
7973 char base64_encoded
[100] = { 0 };
7975 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7977 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7979 else if (hash_mode
== 10400)
7981 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7983 pdf_t
*pdf
= &pdfs
[salt_pos
];
7985 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",
7993 byte_swap_32 (pdf
->id_buf
[0]),
7994 byte_swap_32 (pdf
->id_buf
[1]),
7995 byte_swap_32 (pdf
->id_buf
[2]),
7996 byte_swap_32 (pdf
->id_buf
[3]),
7998 byte_swap_32 (pdf
->u_buf
[0]),
7999 byte_swap_32 (pdf
->u_buf
[1]),
8000 byte_swap_32 (pdf
->u_buf
[2]),
8001 byte_swap_32 (pdf
->u_buf
[3]),
8002 byte_swap_32 (pdf
->u_buf
[4]),
8003 byte_swap_32 (pdf
->u_buf
[5]),
8004 byte_swap_32 (pdf
->u_buf
[6]),
8005 byte_swap_32 (pdf
->u_buf
[7]),
8007 byte_swap_32 (pdf
->o_buf
[0]),
8008 byte_swap_32 (pdf
->o_buf
[1]),
8009 byte_swap_32 (pdf
->o_buf
[2]),
8010 byte_swap_32 (pdf
->o_buf
[3]),
8011 byte_swap_32 (pdf
->o_buf
[4]),
8012 byte_swap_32 (pdf
->o_buf
[5]),
8013 byte_swap_32 (pdf
->o_buf
[6]),
8014 byte_swap_32 (pdf
->o_buf
[7])
8017 else if (hash_mode
== 10410)
8019 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8021 pdf_t
*pdf
= &pdfs
[salt_pos
];
8023 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",
8031 byte_swap_32 (pdf
->id_buf
[0]),
8032 byte_swap_32 (pdf
->id_buf
[1]),
8033 byte_swap_32 (pdf
->id_buf
[2]),
8034 byte_swap_32 (pdf
->id_buf
[3]),
8036 byte_swap_32 (pdf
->u_buf
[0]),
8037 byte_swap_32 (pdf
->u_buf
[1]),
8038 byte_swap_32 (pdf
->u_buf
[2]),
8039 byte_swap_32 (pdf
->u_buf
[3]),
8040 byte_swap_32 (pdf
->u_buf
[4]),
8041 byte_swap_32 (pdf
->u_buf
[5]),
8042 byte_swap_32 (pdf
->u_buf
[6]),
8043 byte_swap_32 (pdf
->u_buf
[7]),
8045 byte_swap_32 (pdf
->o_buf
[0]),
8046 byte_swap_32 (pdf
->o_buf
[1]),
8047 byte_swap_32 (pdf
->o_buf
[2]),
8048 byte_swap_32 (pdf
->o_buf
[3]),
8049 byte_swap_32 (pdf
->o_buf
[4]),
8050 byte_swap_32 (pdf
->o_buf
[5]),
8051 byte_swap_32 (pdf
->o_buf
[6]),
8052 byte_swap_32 (pdf
->o_buf
[7])
8055 else if (hash_mode
== 10420)
8057 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8059 pdf_t
*pdf
= &pdfs
[salt_pos
];
8061 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8063 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",
8071 byte_swap_32 (pdf
->id_buf
[0]),
8072 byte_swap_32 (pdf
->id_buf
[1]),
8073 byte_swap_32 (pdf
->id_buf
[2]),
8074 byte_swap_32 (pdf
->id_buf
[3]),
8076 byte_swap_32 (pdf
->u_buf
[0]),
8077 byte_swap_32 (pdf
->u_buf
[1]),
8078 byte_swap_32 (pdf
->u_buf
[2]),
8079 byte_swap_32 (pdf
->u_buf
[3]),
8080 byte_swap_32 (pdf
->u_buf
[4]),
8081 byte_swap_32 (pdf
->u_buf
[5]),
8082 byte_swap_32 (pdf
->u_buf
[6]),
8083 byte_swap_32 (pdf
->u_buf
[7]),
8085 byte_swap_32 (pdf
->o_buf
[0]),
8086 byte_swap_32 (pdf
->o_buf
[1]),
8087 byte_swap_32 (pdf
->o_buf
[2]),
8088 byte_swap_32 (pdf
->o_buf
[3]),
8089 byte_swap_32 (pdf
->o_buf
[4]),
8090 byte_swap_32 (pdf
->o_buf
[5]),
8091 byte_swap_32 (pdf
->o_buf
[6]),
8092 byte_swap_32 (pdf
->o_buf
[7]),
8100 else if (hash_mode
== 10500)
8102 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8104 pdf_t
*pdf
= &pdfs
[salt_pos
];
8106 if (pdf
->id_len
== 32)
8108 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",
8116 byte_swap_32 (pdf
->id_buf
[0]),
8117 byte_swap_32 (pdf
->id_buf
[1]),
8118 byte_swap_32 (pdf
->id_buf
[2]),
8119 byte_swap_32 (pdf
->id_buf
[3]),
8120 byte_swap_32 (pdf
->id_buf
[4]),
8121 byte_swap_32 (pdf
->id_buf
[5]),
8122 byte_swap_32 (pdf
->id_buf
[6]),
8123 byte_swap_32 (pdf
->id_buf
[7]),
8125 byte_swap_32 (pdf
->u_buf
[0]),
8126 byte_swap_32 (pdf
->u_buf
[1]),
8127 byte_swap_32 (pdf
->u_buf
[2]),
8128 byte_swap_32 (pdf
->u_buf
[3]),
8129 byte_swap_32 (pdf
->u_buf
[4]),
8130 byte_swap_32 (pdf
->u_buf
[5]),
8131 byte_swap_32 (pdf
->u_buf
[6]),
8132 byte_swap_32 (pdf
->u_buf
[7]),
8134 byte_swap_32 (pdf
->o_buf
[0]),
8135 byte_swap_32 (pdf
->o_buf
[1]),
8136 byte_swap_32 (pdf
->o_buf
[2]),
8137 byte_swap_32 (pdf
->o_buf
[3]),
8138 byte_swap_32 (pdf
->o_buf
[4]),
8139 byte_swap_32 (pdf
->o_buf
[5]),
8140 byte_swap_32 (pdf
->o_buf
[6]),
8141 byte_swap_32 (pdf
->o_buf
[7])
8146 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",
8154 byte_swap_32 (pdf
->id_buf
[0]),
8155 byte_swap_32 (pdf
->id_buf
[1]),
8156 byte_swap_32 (pdf
->id_buf
[2]),
8157 byte_swap_32 (pdf
->id_buf
[3]),
8159 byte_swap_32 (pdf
->u_buf
[0]),
8160 byte_swap_32 (pdf
->u_buf
[1]),
8161 byte_swap_32 (pdf
->u_buf
[2]),
8162 byte_swap_32 (pdf
->u_buf
[3]),
8163 byte_swap_32 (pdf
->u_buf
[4]),
8164 byte_swap_32 (pdf
->u_buf
[5]),
8165 byte_swap_32 (pdf
->u_buf
[6]),
8166 byte_swap_32 (pdf
->u_buf
[7]),
8168 byte_swap_32 (pdf
->o_buf
[0]),
8169 byte_swap_32 (pdf
->o_buf
[1]),
8170 byte_swap_32 (pdf
->o_buf
[2]),
8171 byte_swap_32 (pdf
->o_buf
[3]),
8172 byte_swap_32 (pdf
->o_buf
[4]),
8173 byte_swap_32 (pdf
->o_buf
[5]),
8174 byte_swap_32 (pdf
->o_buf
[6]),
8175 byte_swap_32 (pdf
->o_buf
[7])
8179 else if (hash_mode
== 10600)
8181 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8183 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8184 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8186 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8188 else if (hash_mode
== 10700)
8190 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8192 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8193 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8195 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8197 else if (hash_mode
== 10900)
8199 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8201 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8202 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8204 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8206 else if (hash_mode
== 11100)
8208 u32 salt_challenge
= salt
.salt_buf
[0];
8210 salt_challenge
= byte_swap_32 (salt_challenge
);
8212 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8214 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8215 SIGNATURE_POSTGRESQL_AUTH
,
8223 else if (hash_mode
== 11200)
8225 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8226 SIGNATURE_MYSQL_AUTH
,
8227 (unsigned char *) salt
.salt_buf
,
8234 else if (hash_mode
== 11300)
8236 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8238 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8240 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8241 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8242 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8244 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8245 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8246 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8248 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8250 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8252 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8255 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8257 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8259 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8262 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8264 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8266 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8269 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8270 SIGNATURE_BITCOIN_WALLET
,
8274 (unsigned char *) salt
.salt_buf
,
8282 free (cry_master_buf
);
8284 free (public_key_buf
);
8286 else if (hash_mode
== 11400)
8288 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8290 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8291 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8293 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8295 else if (hash_mode
== 11600)
8297 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8299 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8301 const uint data_len
= seven_zip
->data_len
;
8303 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8305 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8307 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8309 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8312 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8313 SIGNATURE_SEVEN_ZIP
,
8317 (char *) seven_zip
->salt_buf
,
8319 seven_zip
->iv_buf
[0],
8320 seven_zip
->iv_buf
[1],
8321 seven_zip
->iv_buf
[2],
8322 seven_zip
->iv_buf
[3],
8324 seven_zip
->data_len
,
8325 seven_zip
->unpack_size
,
8330 else if (hash_mode
== 11700)
8332 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8342 else if (hash_mode
== 11800)
8344 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8362 else if (hash_mode
== 11900)
8364 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8366 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8367 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8369 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8371 else if (hash_mode
== 12000)
8373 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8375 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8376 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8378 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8380 else if (hash_mode
== 12100)
8382 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8384 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8385 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8387 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8389 else if (hash_mode
== 12200)
8391 uint
*ptr_digest
= digest_buf
;
8392 uint
*ptr_salt
= salt
.salt_buf
;
8394 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8401 else if (hash_mode
== 12300)
8403 uint
*ptr_digest
= digest_buf
;
8404 uint
*ptr_salt
= salt
.salt_buf
;
8406 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",
8407 ptr_digest
[ 0], ptr_digest
[ 1],
8408 ptr_digest
[ 2], ptr_digest
[ 3],
8409 ptr_digest
[ 4], ptr_digest
[ 5],
8410 ptr_digest
[ 6], ptr_digest
[ 7],
8411 ptr_digest
[ 8], ptr_digest
[ 9],
8412 ptr_digest
[10], ptr_digest
[11],
8413 ptr_digest
[12], ptr_digest
[13],
8414 ptr_digest
[14], ptr_digest
[15],
8420 else if (hash_mode
== 12400)
8422 // encode iteration count
8424 char salt_iter
[5] = { 0 };
8426 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8427 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8428 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8429 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8434 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8435 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8436 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8437 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8442 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8444 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8445 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8447 memcpy (tmp_buf
, digest_buf
, 8);
8449 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8453 // fill the resulting buffer
8455 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8457 else if (hash_mode
== 12500)
8459 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8461 byte_swap_32 (salt
.salt_buf
[0]),
8462 byte_swap_32 (salt
.salt_buf
[1]),
8468 else if (hash_mode
== 12600)
8470 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8471 digest_buf
[0] + salt
.salt_buf_pc
[0],
8472 digest_buf
[1] + salt
.salt_buf_pc
[1],
8473 digest_buf
[2] + salt
.salt_buf_pc
[2],
8474 digest_buf
[3] + salt
.salt_buf_pc
[3],
8475 digest_buf
[4] + salt
.salt_buf_pc
[4],
8476 digest_buf
[5] + salt
.salt_buf_pc
[5],
8477 digest_buf
[6] + salt
.salt_buf_pc
[6],
8478 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8480 else if (hash_mode
== 12700)
8482 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8484 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8485 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8487 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8489 else if (hash_mode
== 12800)
8491 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8493 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",
8506 byte_swap_32 (digest_buf
[0]),
8507 byte_swap_32 (digest_buf
[1]),
8508 byte_swap_32 (digest_buf
[2]),
8509 byte_swap_32 (digest_buf
[3]),
8510 byte_swap_32 (digest_buf
[4]),
8511 byte_swap_32 (digest_buf
[5]),
8512 byte_swap_32 (digest_buf
[6]),
8513 byte_swap_32 (digest_buf
[7])
8516 else if (hash_mode
== 12900)
8518 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",
8527 byte_swap_32 (digest_buf
[0]),
8528 byte_swap_32 (digest_buf
[1]),
8529 byte_swap_32 (digest_buf
[2]),
8530 byte_swap_32 (digest_buf
[3]),
8531 byte_swap_32 (digest_buf
[4]),
8532 byte_swap_32 (digest_buf
[5]),
8533 byte_swap_32 (digest_buf
[6]),
8534 byte_swap_32 (digest_buf
[7]),
8541 else if (hash_mode
== 13000)
8543 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8545 rar5_t
*rar5
= &rar5s
[salt_pos
];
8547 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8557 byte_swap_32 (digest_buf
[0]),
8558 byte_swap_32 (digest_buf
[1])
8561 else if (hash_mode
== 13100)
8563 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8565 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8567 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8568 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8570 char data
[2560 * 4 * 2] = { 0 };
8572 char *ptr_data
= data
;
8574 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8575 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8580 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8581 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8583 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8585 (char *) krb5tgs
->account_info
,
8589 else if (hash_mode
== 13200)
8591 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8605 else if (hash_mode
== 13300)
8607 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8608 SIGNATURE_AXCRYPT_SHA1
,
8614 else if (hash_mode
== 13400)
8616 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8618 keepass_t
*keepass
= &keepasss
[salt_pos
];
8620 u32 version
= (u32
) keepass
->version
;
8621 u32 rounds
= salt
.salt_iter
;
8622 u32 algorithm
= (u32
) keepass
->algorithm
;
8623 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8625 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8626 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8627 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8628 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8629 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8631 /* specific to version 1 */
8635 /* specific to version 2 */
8636 u32 expected_bytes_len
;
8637 u32
*ptr_expected_bytes
;
8639 u32 final_random_seed_len
;
8640 u32 transf_random_seed_len
;
8642 u32 contents_hash_len
;
8644 transf_random_seed_len
= 8;
8646 contents_hash_len
= 8;
8647 final_random_seed_len
= 8;
8650 final_random_seed_len
= 4;
8652 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8658 char *ptr_data
= out_buf
;
8660 ptr_data
+= strlen(out_buf
);
8665 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8666 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8671 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8672 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8677 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8678 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8685 contents_len
= (u32
) keepass
->contents_len
;
8686 ptr_contents
= (u32
*) keepass
->contents
;
8688 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8689 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8701 char ptr_contents_len
[10] = { 0 };
8703 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8705 sprintf (ptr_data
, "%d", contents_len
);
8707 ptr_data
+= strlen(ptr_contents_len
);
8712 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8713 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8715 else if (version
== 2)
8717 expected_bytes_len
= 8;
8718 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8720 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8721 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8726 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8727 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8741 sprintf (ptr_data
, "%d", keyfile_len
);
8748 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8749 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8752 else if (hash_mode
== 13500)
8754 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8756 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8758 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8760 char pstoken_tmp
[1024 + 1] = { 0 };
8762 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8764 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8766 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8769 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8777 else if (hash_mode
== 13600)
8779 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8781 zip2_t
*zip2
= &zip2s
[salt_pos
];
8783 const u32 salt_len
= zip2
->salt_len
;
8785 char salt_tmp
[32 + 1] = { 0 };
8787 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8789 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8791 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8794 const u32 data_len
= zip2
->data_len
;
8796 char data_tmp
[8192 + 1] = { 0 };
8798 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8800 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8802 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8805 const u32 auth_len
= zip2
->auth_len
;
8807 char auth_tmp
[20 + 1] = { 0 };
8809 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8811 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8813 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8816 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8817 SIGNATURE_ZIP2_START
,
8823 zip2
->compress_length
,
8826 SIGNATURE_ZIP2_STOP
);
8828 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8830 snprintf (out_buf
, len
-1, "%s", hashfile
);
8832 else if (hash_mode
== 13800)
8834 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8836 win8phone_t
*esalt
= &esalts
[salt_pos
];
8838 char buf
[256 + 1] = { 0 };
8840 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8842 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8845 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8858 if (hash_type
== HASH_TYPE_MD4
)
8860 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8866 else if (hash_type
== HASH_TYPE_MD5
)
8868 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8874 else if (hash_type
== HASH_TYPE_SHA1
)
8876 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8883 else if (hash_type
== HASH_TYPE_SHA256
)
8885 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8895 else if (hash_type
== HASH_TYPE_SHA384
)
8897 uint
*ptr
= digest_buf
;
8899 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8907 else if (hash_type
== HASH_TYPE_SHA512
)
8909 uint
*ptr
= digest_buf
;
8911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8921 else if (hash_type
== HASH_TYPE_LM
)
8923 snprintf (out_buf
, len
-1, "%08x%08x",
8927 else if (hash_type
== HASH_TYPE_ORACLEH
)
8929 snprintf (out_buf
, len
-1, "%08X%08X",
8933 else if (hash_type
== HASH_TYPE_BCRYPT
)
8935 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8936 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8938 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8940 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8942 else if (hash_type
== HASH_TYPE_KECCAK
)
8944 uint
*ptr
= digest_buf
;
8946 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",
8974 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8976 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8978 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8985 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8987 digest_buf
[ 0] = digest_buf
[ 0];
8988 digest_buf
[ 1] = digest_buf
[ 1];
8989 digest_buf
[ 2] = digest_buf
[ 2];
8990 digest_buf
[ 3] = digest_buf
[ 3];
8991 digest_buf
[ 4] = digest_buf
[ 4];
8992 digest_buf
[ 5] = digest_buf
[ 5];
8993 digest_buf
[ 6] = digest_buf
[ 6];
8994 digest_buf
[ 7] = digest_buf
[ 7];
8995 digest_buf
[ 8] = digest_buf
[ 8];
8996 digest_buf
[ 9] = digest_buf
[ 9];
8997 digest_buf
[10] = digest_buf
[10];
8998 digest_buf
[11] = digest_buf
[11];
8999 digest_buf
[12] = digest_buf
[12];
9000 digest_buf
[13] = digest_buf
[13];
9001 digest_buf
[14] = digest_buf
[14];
9002 digest_buf
[15] = digest_buf
[15];
9004 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9022 else if (hash_type
== HASH_TYPE_GOST
)
9024 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9034 else if (hash_type
== HASH_TYPE_MYSQL
)
9036 snprintf (out_buf
, len
-1, "%08x%08x",
9040 else if (hash_type
== HASH_TYPE_LOTUS5
)
9042 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9048 else if (hash_type
== HASH_TYPE_LOTUS6
)
9050 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9051 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9052 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9053 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9055 char buf
[16] = { 0 };
9057 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9058 memcpy (buf
+ 5, digest_buf
, 9);
9062 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9064 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9067 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9069 else if (hash_type
== HASH_TYPE_LOTUS8
)
9071 char buf
[52] = { 0 };
9075 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9081 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9085 buf
[26] = salt
.salt_buf_pc
[0];
9086 buf
[27] = salt
.salt_buf_pc
[1];
9090 memcpy (buf
+ 28, digest_buf
, 8);
9092 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9096 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9098 else if (hash_type
== HASH_TYPE_CRC32
)
9100 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9104 if (salt_type
== SALT_TYPE_INTERN
)
9106 size_t pos
= strlen (out_buf
);
9108 out_buf
[pos
] = data
.separator
;
9110 char *ptr
= (char *) salt
.salt_buf
;
9112 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9114 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9118 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9120 memset (hccap
, 0, sizeof (hccap_t
));
9122 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9124 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9126 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9127 wpa_t
*wpa
= &wpas
[salt_pos
];
9129 hccap
->keyver
= wpa
->keyver
;
9131 hccap
->eapol_size
= wpa
->eapol_size
;
9133 if (wpa
->keyver
!= 1)
9135 uint eapol_tmp
[64] = { 0 };
9137 for (uint i
= 0; i
< 64; i
++)
9139 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9142 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9146 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9149 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9150 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9151 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9152 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9154 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9156 uint dgst_size
= data
.dgst_size
;
9158 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9160 if (wpa
->keyver
!= 1)
9162 uint digest_tmp
[4] = { 0 };
9164 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9165 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9166 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9167 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9169 memcpy (hccap
->keymic
, digest_tmp
, 16);
9173 memcpy (hccap
->keymic
, digest_ptr
, 16);
9177 void SuspendThreads ()
9179 if (data
.devices_status
!= STATUS_RUNNING
) return;
9181 hc_timer_set (&data
.timer_paused
);
9183 data
.devices_status
= STATUS_PAUSED
;
9185 log_info ("Paused");
9188 void ResumeThreads ()
9190 if (data
.devices_status
!= STATUS_PAUSED
) return;
9194 hc_timer_get (data
.timer_paused
, ms_paused
);
9196 data
.ms_paused
+= ms_paused
;
9198 data
.devices_status
= STATUS_RUNNING
;
9200 log_info ("Resumed");
9205 data
.devices_status
= STATUS_BYPASS
;
9207 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9210 void stop_at_checkpoint ()
9212 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9214 if (data
.devices_status
!= STATUS_RUNNING
) return;
9217 // this feature only makes sense if --restore-disable was not specified
9219 if (data
.restore_disable
== 1)
9221 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9226 // check if monitoring of Restore Point updates should be enabled or disabled
9228 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9230 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9232 // save the current restore point value
9234 data
.checkpoint_cur_words
= get_lowest_words_done ();
9236 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9240 data
.devices_status
= STATUS_RUNNING
;
9242 // reset the global value for checkpoint checks
9244 data
.checkpoint_cur_words
= 0;
9246 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9252 data
.devices_status
= STATUS_ABORTED
;
9257 data
.devices_status
= STATUS_QUIT
;
9260 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9262 const size_t len
= strlen (s
);
9264 for (size_t in
= 0; in
< len
; in
++)
9270 s
[in
] = replace_char
;
9275 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9277 char s_escaped
[1024] = { 0 };
9279 size_t s_escaped_max
= sizeof (s_escaped
);
9281 const size_t len
= strlen (s
);
9283 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9289 s_escaped
[out
] = escape_char
;
9294 if (out
== s_escaped_max
- 2) break;
9299 strncpy (s
, s_escaped
, s_max
- 1);
9302 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9304 FILE *fp
= fopen (kernel_file
, "rb");
9310 memset (&st
, 0, sizeof (st
));
9312 stat (kernel_file
, &st
);
9314 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9316 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9318 if (num_read
!= (size_t) st
.st_size
)
9320 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9327 buf
[st
.st_size
] = 0;
9329 for (int i
= 0; i
< num_devices
; i
++)
9331 kernel_lengths
[i
] = (size_t) st
.st_size
;
9333 kernel_sources
[i
] = buf
;
9338 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9346 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9348 if (binary_size
> 0)
9350 FILE *fp
= fopen (dst
, "wb");
9353 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9364 restore_data_t
*init_restore (int argc
, char **argv
)
9366 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9368 if (data
.restore_disable
== 0)
9370 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9374 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9378 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9387 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9389 int pidbin_len
= -1;
9392 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9394 FILE *fd
= fopen (pidbin
, "rb");
9398 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9400 pidbin
[pidbin_len
] = 0;
9404 char *argv0_r
= strrchr (argv
[0], '/');
9406 char *pidbin_r
= strrchr (pidbin
, '/');
9408 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9410 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9412 if (strcmp (argv0_r
, pidbin_r
) == 0)
9414 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9421 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9423 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9425 int pidbin2_len
= -1;
9427 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9428 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9430 pidbin
[pidbin_len
] = 0;
9431 pidbin2
[pidbin2_len
] = 0;
9435 if (strcmp (pidbin
, pidbin2
) == 0)
9437 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9450 if (rd
->version_bin
< RESTORE_MIN
)
9452 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9459 memset (rd
, 0, sizeof (restore_data_t
));
9461 rd
->version_bin
= VERSION_BIN
;
9464 rd
->pid
= getpid ();
9466 rd
->pid
= GetCurrentProcessId ();
9469 if (getcwd (rd
->cwd
, 255) == NULL
)
9482 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9484 FILE *fp
= fopen (eff_restore_file
, "rb");
9488 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9493 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9495 log_error ("ERROR: Can't read %s", eff_restore_file
);
9500 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9502 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9504 for (uint i
= 0; i
< rd
->argc
; i
++)
9506 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9508 log_error ("ERROR: Can't read %s", eff_restore_file
);
9513 size_t len
= strlen (buf
);
9515 if (len
) buf
[len
- 1] = 0;
9517 rd
->argv
[i
] = mystrdup (buf
);
9524 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9526 if (chdir (rd
->cwd
))
9528 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9529 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9530 " https://github.com/philsmd/analyze_hc_restore\n"
9531 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9537 u64
get_lowest_words_done ()
9541 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9543 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9545 if (device_param
->skipped
) continue;
9547 const u64 words_done
= device_param
->words_done
;
9549 if (words_done
< words_cur
) words_cur
= words_done
;
9552 // It's possible that a device's workload isn't finished right after a restore-case.
9553 // In that case, this function would return 0 and overwrite the real restore point
9554 // There's also data.words_cur which is set to rd->words_cur but it changes while
9555 // the attack is running therefore we should stick to rd->words_cur.
9556 // Note that -s influences rd->words_cur we should keep a close look on that.
9558 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9563 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9565 u64 words_cur
= get_lowest_words_done ();
9567 rd
->words_cur
= words_cur
;
9569 FILE *fp
= fopen (new_restore_file
, "wb");
9573 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9578 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9580 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9585 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9587 for (uint i
= 0; i
< rd
->argc
; i
++)
9589 fprintf (fp
, "%s", rd
->argv
[i
]);
9595 fsync (fileno (fp
));
9600 void cycle_restore ()
9602 const char *eff_restore_file
= data
.eff_restore_file
;
9603 const char *new_restore_file
= data
.new_restore_file
;
9605 restore_data_t
*rd
= data
.rd
;
9607 write_restore (new_restore_file
, rd
);
9611 memset (&st
, 0, sizeof(st
));
9613 if (stat (eff_restore_file
, &st
) == 0)
9615 if (unlink (eff_restore_file
))
9617 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9621 if (rename (new_restore_file
, eff_restore_file
))
9623 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9627 void check_checkpoint ()
9629 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9631 u64 words_cur
= get_lowest_words_done ();
9633 if (words_cur
!= data
.checkpoint_cur_words
)
9643 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9647 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9649 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9651 myfree (alias
->device_name
);
9652 myfree (alias
->alias_name
);
9655 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9657 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9659 myfree (entry
->device_name
);
9662 myfree (tuning_db
->alias_buf
);
9663 myfree (tuning_db
->entry_buf
);
9668 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9670 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9672 int num_lines
= count_lines (fp
);
9674 // a bit over-allocated
9676 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9677 tuning_db
->alias_cnt
= 0;
9679 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9680 tuning_db
->entry_cnt
= 0;
9685 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9687 FILE *fp
= fopen (tuning_db_file
, "rb");
9691 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9696 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9702 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9706 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9708 if (line_buf
== NULL
) break;
9712 const int line_len
= in_superchop (line_buf
);
9714 if (line_len
== 0) continue;
9716 if (line_buf
[0] == '#') continue;
9720 char *token_ptr
[7] = { NULL
};
9724 char *next
= strtok (line_buf
, "\t ");
9726 token_ptr
[token_cnt
] = next
;
9730 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9732 token_ptr
[token_cnt
] = next
;
9739 char *device_name
= token_ptr
[0];
9740 char *alias_name
= token_ptr
[1];
9742 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9744 alias
->device_name
= mystrdup (device_name
);
9745 alias
->alias_name
= mystrdup (alias_name
);
9747 tuning_db
->alias_cnt
++;
9749 else if (token_cnt
== 6)
9751 if ((token_ptr
[1][0] != '0') &&
9752 (token_ptr
[1][0] != '1') &&
9753 (token_ptr
[1][0] != '3') &&
9754 (token_ptr
[1][0] != '*'))
9756 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9761 if ((token_ptr
[3][0] != '1') &&
9762 (token_ptr
[3][0] != '2') &&
9763 (token_ptr
[3][0] != '4') &&
9764 (token_ptr
[3][0] != '8') &&
9765 (token_ptr
[3][0] != 'N'))
9767 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9772 char *device_name
= token_ptr
[0];
9774 int attack_mode
= -1;
9776 int vector_width
= -1;
9777 int kernel_accel
= -1;
9778 int kernel_loops
= -1;
9780 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9781 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9782 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9784 if (token_ptr
[4][0] != 'A')
9786 kernel_accel
= atoi (token_ptr
[4]);
9788 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9790 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9800 if (token_ptr
[5][0] != 'A')
9802 kernel_loops
= atoi (token_ptr
[5]);
9804 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9806 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9816 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9818 entry
->device_name
= mystrdup (device_name
);
9819 entry
->attack_mode
= attack_mode
;
9820 entry
->hash_type
= hash_type
;
9821 entry
->vector_width
= vector_width
;
9822 entry
->kernel_accel
= kernel_accel
;
9823 entry
->kernel_loops
= kernel_loops
;
9825 tuning_db
->entry_cnt
++;
9829 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9839 // todo: print loaded 'cnt' message
9841 // sort the database
9843 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9844 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9849 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9851 static tuning_db_entry_t s
;
9853 // first we need to convert all spaces in the device_name to underscore
9855 char *device_name_nospace
= strdup (device_param
->device_name
);
9857 int device_name_length
= strlen (device_name_nospace
);
9861 for (i
= 0; i
< device_name_length
; i
++)
9863 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9866 // find out if there's an alias configured
9868 tuning_db_alias_t a
;
9870 a
.device_name
= device_name_nospace
;
9872 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
);
9874 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9876 // attack-mode 6 and 7 are attack-mode 1 basically
9878 if (attack_mode
== 6) attack_mode
= 1;
9879 if (attack_mode
== 7) attack_mode
= 1;
9881 // bsearch is not ideal but fast enough
9883 s
.device_name
= device_name_nospace
;
9884 s
.attack_mode
= attack_mode
;
9885 s
.hash_type
= hash_type
;
9887 tuning_db_entry_t
*entry
= NULL
;
9889 // this will produce all 2^3 combinations required
9891 for (i
= 0; i
< 8; i
++)
9893 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9894 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9895 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9897 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9899 if (entry
!= NULL
) break;
9901 // in non-wildcard mode do some additional checks:
9905 // in case we have an alias-name
9907 if (alias_name
!= NULL
)
9909 s
.device_name
= alias_name
;
9911 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9913 if (entry
!= NULL
) break;
9916 // or by device type
9918 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9920 s
.device_name
= "DEVICE_TYPE_CPU";
9922 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9924 s
.device_name
= "DEVICE_TYPE_GPU";
9926 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9928 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9931 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9933 if (entry
!= NULL
) break;
9937 // free converted device_name
9939 myfree (device_name_nospace
);
9948 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9950 u8 tmp
[256] = { 0 };
9952 if (salt_len
> sizeof (tmp
))
9957 memcpy (tmp
, in
, salt_len
);
9959 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9961 if ((salt_len
% 2) == 0)
9963 u32 new_salt_len
= salt_len
/ 2;
9965 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9970 tmp
[i
] = hex_convert (p1
) << 0;
9971 tmp
[i
] |= hex_convert (p0
) << 4;
9974 salt_len
= new_salt_len
;
9981 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9983 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9986 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9988 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9992 u32
*tmp_uint
= (u32
*) tmp
;
9994 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9995 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9996 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9997 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9998 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9999 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
10000 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
10001 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
10002 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
10003 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10005 salt_len
= salt_len
* 2;
10013 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10015 lowercase (tmp
, salt_len
);
10018 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10020 uppercase (tmp
, salt_len
);
10023 u32 len
= salt_len
;
10025 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10030 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10035 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10037 u32
*tmp_uint
= (uint
*) tmp
;
10041 if (len
% 4) max
++;
10043 for (u32 i
= 0; i
< max
; i
++)
10045 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10048 // Important: we may need to increase the length of memcpy since
10049 // we don't want to "loose" some swapped bytes (could happen if
10050 // they do not perfectly fit in the 4-byte blocks)
10051 // Memcpy does always copy the bytes in the BE order, but since
10052 // we swapped them, some important bytes could be in positions
10053 // we normally skip with the original len
10055 if (len
% 4) len
+= 4 - (len
% 4);
10058 memcpy (out
, tmp
, len
);
10063 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10065 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10067 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10069 u32
*digest
= (u32
*) hash_buf
->digest
;
10071 salt_t
*salt
= hash_buf
->salt
;
10073 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10075 char *iter_pos
= input_buf
+ 4;
10077 salt
->salt_iter
= 1 << atoi (iter_pos
);
10079 char *salt_pos
= strchr (iter_pos
, '$');
10081 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10085 uint salt_len
= 16;
10087 salt
->salt_len
= salt_len
;
10089 u8 tmp_buf
[100] = { 0 };
10091 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10093 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10095 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10097 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10098 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10099 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10100 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10102 char *hash_pos
= salt_pos
+ 22;
10104 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10106 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10108 memcpy (digest
, tmp_buf
, 24);
10110 digest
[0] = byte_swap_32 (digest
[0]);
10111 digest
[1] = byte_swap_32 (digest
[1]);
10112 digest
[2] = byte_swap_32 (digest
[2]);
10113 digest
[3] = byte_swap_32 (digest
[3]);
10114 digest
[4] = byte_swap_32 (digest
[4]);
10115 digest
[5] = byte_swap_32 (digest
[5]);
10117 digest
[5] &= ~0xff; // its just 23 not 24 !
10119 return (PARSER_OK
);
10122 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10124 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10126 u32
*digest
= (u32
*) hash_buf
->digest
;
10128 u8 tmp_buf
[100] = { 0 };
10130 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10132 memcpy (digest
, tmp_buf
, 32);
10134 digest
[0] = byte_swap_32 (digest
[0]);
10135 digest
[1] = byte_swap_32 (digest
[1]);
10136 digest
[2] = byte_swap_32 (digest
[2]);
10137 digest
[3] = byte_swap_32 (digest
[3]);
10138 digest
[4] = byte_swap_32 (digest
[4]);
10139 digest
[5] = byte_swap_32 (digest
[5]);
10140 digest
[6] = byte_swap_32 (digest
[6]);
10141 digest
[7] = byte_swap_32 (digest
[7]);
10143 digest
[0] -= SHA256M_A
;
10144 digest
[1] -= SHA256M_B
;
10145 digest
[2] -= SHA256M_C
;
10146 digest
[3] -= SHA256M_D
;
10147 digest
[4] -= SHA256M_E
;
10148 digest
[5] -= SHA256M_F
;
10149 digest
[6] -= SHA256M_G
;
10150 digest
[7] -= SHA256M_H
;
10152 return (PARSER_OK
);
10155 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10157 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10159 u32
*digest
= (u32
*) hash_buf
->digest
;
10161 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10162 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10164 digest
[0] = byte_swap_32 (digest
[0]);
10165 digest
[1] = byte_swap_32 (digest
[1]);
10169 IP (digest
[0], digest
[1], tt
);
10171 digest
[0] = digest
[0];
10172 digest
[1] = digest
[1];
10176 return (PARSER_OK
);
10179 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10181 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10183 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10185 u32
*digest
= (u32
*) hash_buf
->digest
;
10187 salt_t
*salt
= hash_buf
->salt
;
10189 char *hash_pos
= input_buf
+ 10;
10191 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10192 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10193 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10194 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10195 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10197 digest
[0] -= SHA1M_A
;
10198 digest
[1] -= SHA1M_B
;
10199 digest
[2] -= SHA1M_C
;
10200 digest
[3] -= SHA1M_D
;
10201 digest
[4] -= SHA1M_E
;
10203 uint salt_len
= 10;
10205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10207 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10211 salt
->salt_len
= salt_len
;
10213 return (PARSER_OK
);
10216 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10218 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10220 u32
*digest
= (u32
*) hash_buf
->digest
;
10222 salt_t
*salt
= hash_buf
->salt
;
10224 char *hash_pos
= input_buf
+ 8;
10226 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10227 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10228 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10229 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10230 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10232 digest
[0] -= SHA1M_A
;
10233 digest
[1] -= SHA1M_B
;
10234 digest
[2] -= SHA1M_C
;
10235 digest
[3] -= SHA1M_D
;
10236 digest
[4] -= SHA1M_E
;
10240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10242 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10246 salt
->salt_len
= salt_len
;
10248 return (PARSER_OK
);
10251 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10253 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10255 u64
*digest
= (u64
*) hash_buf
->digest
;
10257 salt_t
*salt
= hash_buf
->salt
;
10259 char *hash_pos
= input_buf
+ 8;
10261 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10262 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10263 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10264 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10265 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10266 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10267 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10268 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10270 digest
[0] -= SHA512M_A
;
10271 digest
[1] -= SHA512M_B
;
10272 digest
[2] -= SHA512M_C
;
10273 digest
[3] -= SHA512M_D
;
10274 digest
[4] -= SHA512M_E
;
10275 digest
[5] -= SHA512M_F
;
10276 digest
[6] -= SHA512M_G
;
10277 digest
[7] -= SHA512M_H
;
10281 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10283 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10285 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10287 salt
->salt_len
= salt_len
;
10289 return (PARSER_OK
);
10292 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10294 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10296 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10300 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10303 u32
*digest
= (u32
*) hash_buf
->digest
;
10305 salt_t
*salt
= hash_buf
->salt
;
10307 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10308 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10309 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10310 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10312 digest
[0] = byte_swap_32 (digest
[0]);
10313 digest
[1] = byte_swap_32 (digest
[1]);
10314 digest
[2] = byte_swap_32 (digest
[2]);
10315 digest
[3] = byte_swap_32 (digest
[3]);
10317 digest
[0] -= MD5M_A
;
10318 digest
[1] -= MD5M_B
;
10319 digest
[2] -= MD5M_C
;
10320 digest
[3] -= MD5M_D
;
10322 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10324 uint salt_len
= input_len
- 32 - 1;
10326 char *salt_buf
= input_buf
+ 32 + 1;
10328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10330 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10332 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10334 salt
->salt_len
= salt_len
;
10336 return (PARSER_OK
);
10339 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10341 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10343 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10347 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10352 char clean_input_buf
[32] = { 0 };
10354 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10355 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10357 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10361 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10367 clean_input_buf
[k
] = input_buf
[i
];
10375 u32
*digest
= (u32
*) hash_buf
->digest
;
10377 salt_t
*salt
= hash_buf
->salt
;
10379 u32 a
, b
, c
, d
, e
, f
;
10381 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10382 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10383 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10384 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10385 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10386 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10388 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10389 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10391 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10392 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10393 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10394 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10395 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10396 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10398 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10399 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10401 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10402 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10403 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10404 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10405 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10406 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10408 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10409 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10411 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10412 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10413 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10414 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10415 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10416 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10418 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10419 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10421 digest
[0] = byte_swap_32 (digest
[0]);
10422 digest
[1] = byte_swap_32 (digest
[1]);
10423 digest
[2] = byte_swap_32 (digest
[2]);
10424 digest
[3] = byte_swap_32 (digest
[3]);
10426 digest
[0] -= MD5M_A
;
10427 digest
[1] -= MD5M_B
;
10428 digest
[2] -= MD5M_C
;
10429 digest
[3] -= MD5M_D
;
10431 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10433 uint salt_len
= input_len
- 30 - 1;
10435 char *salt_buf
= input_buf
+ 30 + 1;
10437 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10439 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10441 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10442 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10444 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10446 salt
->salt_len
= salt_len
;
10448 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10450 salt
->salt_len
+= 22;
10452 return (PARSER_OK
);
10455 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10457 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10459 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10463 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10466 u32
*digest
= (u32
*) hash_buf
->digest
;
10468 salt_t
*salt
= hash_buf
->salt
;
10470 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10471 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10472 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10473 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10474 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10476 digest
[0] -= SHA1M_A
;
10477 digest
[1] -= SHA1M_B
;
10478 digest
[2] -= SHA1M_C
;
10479 digest
[3] -= SHA1M_D
;
10480 digest
[4] -= SHA1M_E
;
10482 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10484 uint salt_len
= input_len
- 40 - 1;
10486 char *salt_buf
= input_buf
+ 40 + 1;
10488 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10490 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10492 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10494 salt
->salt_len
= salt_len
;
10496 return (PARSER_OK
);
10499 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10501 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10503 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10507 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10510 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10512 char *iter_pos
= input_buf
+ 6;
10514 salt_t
*salt
= hash_buf
->salt
;
10516 uint iter
= atoi (iter_pos
);
10520 iter
= ROUNDS_DCC2
;
10523 salt
->salt_iter
= iter
- 1;
10525 char *salt_pos
= strchr (iter_pos
, '#');
10527 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10531 char *digest_pos
= strchr (salt_pos
, '#');
10533 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10537 uint salt_len
= digest_pos
- salt_pos
- 1;
10539 u32
*digest
= (u32
*) hash_buf
->digest
;
10541 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10542 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10543 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10544 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10546 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10548 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10550 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10552 salt
->salt_len
= salt_len
;
10554 return (PARSER_OK
);
10557 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10559 u32
*digest
= (u32
*) hash_buf
->digest
;
10561 salt_t
*salt
= hash_buf
->salt
;
10563 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10567 memcpy (&in
, input_buf
, input_len
);
10569 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10571 memcpy (digest
, in
.keymic
, 16);
10574 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10575 The phrase "Pairwise key expansion"
10576 Access Point Address (referred to as Authenticator Address AA)
10577 Supplicant Address (referred to as Supplicant Address SA)
10578 Access Point Nonce (referred to as Authenticator Anonce)
10579 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10582 uint salt_len
= strlen (in
.essid
);
10586 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10588 return (PARSER_SALT_LENGTH
);
10591 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10593 salt
->salt_len
= salt_len
;
10595 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10597 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10599 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10601 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10603 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10604 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10608 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10609 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10612 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10614 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10615 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10619 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10620 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10623 for (int i
= 0; i
< 25; i
++)
10625 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10628 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10629 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10630 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10631 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10633 wpa
->keyver
= in
.keyver
;
10635 if (wpa
->keyver
> 255)
10637 log_info ("ATTENTION!");
10638 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10639 log_info (" This could be due to a recent aircrack-ng bug.");
10640 log_info (" The key version was automatically reset to a reasonable value.");
10643 wpa
->keyver
&= 0xff;
10646 wpa
->eapol_size
= in
.eapol_size
;
10648 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10650 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10652 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10654 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10656 if (wpa
->keyver
== 1)
10662 digest
[0] = byte_swap_32 (digest
[0]);
10663 digest
[1] = byte_swap_32 (digest
[1]);
10664 digest
[2] = byte_swap_32 (digest
[2]);
10665 digest
[3] = byte_swap_32 (digest
[3]);
10667 for (int i
= 0; i
< 64; i
++)
10669 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10673 uint32_t *p0
= (uint32_t *) in
.essid
;
10677 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10678 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10680 salt
->salt_buf
[10] = c0
;
10681 salt
->salt_buf
[11] = c1
;
10683 return (PARSER_OK
);
10686 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10688 u32
*digest
= (u32
*) hash_buf
->digest
;
10690 salt_t
*salt
= hash_buf
->salt
;
10692 if (input_len
== 0)
10694 log_error ("Password Safe v2 container not specified");
10699 FILE *fp
= fopen (input_buf
, "rb");
10703 log_error ("%s: %s", input_buf
, strerror (errno
));
10710 memset (&buf
, 0, sizeof (psafe2_hdr
));
10712 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10716 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10718 salt
->salt_buf
[0] = buf
.random
[0];
10719 salt
->salt_buf
[1] = buf
.random
[1];
10721 salt
->salt_len
= 8;
10722 salt
->salt_iter
= 1000;
10724 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10725 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10726 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10727 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10728 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10730 return (PARSER_OK
);
10733 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10735 u32
*digest
= (u32
*) hash_buf
->digest
;
10737 salt_t
*salt
= hash_buf
->salt
;
10739 if (input_len
== 0)
10741 log_error (".psafe3 not specified");
10746 FILE *fp
= fopen (input_buf
, "rb");
10750 log_error ("%s: %s", input_buf
, strerror (errno
));
10757 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10761 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10763 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10765 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10767 salt
->salt_iter
= in
.iterations
+ 1;
10769 salt
->salt_buf
[0] = in
.salt_buf
[0];
10770 salt
->salt_buf
[1] = in
.salt_buf
[1];
10771 salt
->salt_buf
[2] = in
.salt_buf
[2];
10772 salt
->salt_buf
[3] = in
.salt_buf
[3];
10773 salt
->salt_buf
[4] = in
.salt_buf
[4];
10774 salt
->salt_buf
[5] = in
.salt_buf
[5];
10775 salt
->salt_buf
[6] = in
.salt_buf
[6];
10776 salt
->salt_buf
[7] = in
.salt_buf
[7];
10778 salt
->salt_len
= 32;
10780 digest
[0] = in
.hash_buf
[0];
10781 digest
[1] = in
.hash_buf
[1];
10782 digest
[2] = in
.hash_buf
[2];
10783 digest
[3] = in
.hash_buf
[3];
10784 digest
[4] = in
.hash_buf
[4];
10785 digest
[5] = in
.hash_buf
[5];
10786 digest
[6] = in
.hash_buf
[6];
10787 digest
[7] = in
.hash_buf
[7];
10789 digest
[0] = byte_swap_32 (digest
[0]);
10790 digest
[1] = byte_swap_32 (digest
[1]);
10791 digest
[2] = byte_swap_32 (digest
[2]);
10792 digest
[3] = byte_swap_32 (digest
[3]);
10793 digest
[4] = byte_swap_32 (digest
[4]);
10794 digest
[5] = byte_swap_32 (digest
[5]);
10795 digest
[6] = byte_swap_32 (digest
[6]);
10796 digest
[7] = byte_swap_32 (digest
[7]);
10798 return (PARSER_OK
);
10801 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10803 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10805 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10807 u32
*digest
= (u32
*) hash_buf
->digest
;
10809 salt_t
*salt
= hash_buf
->salt
;
10811 char *iter_pos
= input_buf
+ 3;
10813 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10815 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10817 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10819 salt
->salt_iter
= salt_iter
;
10821 char *salt_pos
= iter_pos
+ 1;
10825 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10827 salt
->salt_len
= salt_len
;
10829 char *hash_pos
= salt_pos
+ salt_len
;
10831 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10833 return (PARSER_OK
);
10836 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10838 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10840 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10842 u32
*digest
= (u32
*) hash_buf
->digest
;
10844 salt_t
*salt
= hash_buf
->salt
;
10846 char *salt_pos
= input_buf
+ 3;
10848 uint iterations_len
= 0;
10850 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10854 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10856 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10857 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10861 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10865 iterations_len
+= 8;
10869 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10872 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10874 char *hash_pos
= strchr (salt_pos
, '$');
10876 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10878 uint salt_len
= hash_pos
- salt_pos
;
10880 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10882 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10884 salt
->salt_len
= salt_len
;
10888 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10890 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10892 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10894 return (PARSER_OK
);
10897 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10899 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10901 u32
*digest
= (u32
*) hash_buf
->digest
;
10903 salt_t
*salt
= hash_buf
->salt
;
10905 char *salt_pos
= input_buf
+ 6;
10907 uint iterations_len
= 0;
10909 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10913 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10915 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10916 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10920 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10924 iterations_len
+= 8;
10928 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10931 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10933 char *hash_pos
= strchr (salt_pos
, '$');
10935 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10937 uint salt_len
= hash_pos
- salt_pos
;
10939 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10941 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10943 salt
->salt_len
= salt_len
;
10947 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10949 return (PARSER_OK
);
10952 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10954 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10956 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10958 u32
*digest
= (u32
*) hash_buf
->digest
;
10960 salt_t
*salt
= hash_buf
->salt
;
10962 char *salt_pos
= input_buf
+ 14;
10964 char *hash_pos
= strchr (salt_pos
, '*');
10966 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10970 uint salt_len
= hash_pos
- salt_pos
- 1;
10972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10974 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10978 salt
->salt_len
= salt_len
;
10980 u8 tmp_buf
[100] = { 0 };
10982 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10984 memcpy (digest
, tmp_buf
, 20);
10986 digest
[0] = byte_swap_32 (digest
[0]);
10987 digest
[1] = byte_swap_32 (digest
[1]);
10988 digest
[2] = byte_swap_32 (digest
[2]);
10989 digest
[3] = byte_swap_32 (digest
[3]);
10990 digest
[4] = byte_swap_32 (digest
[4]);
10992 digest
[0] -= SHA1M_A
;
10993 digest
[1] -= SHA1M_B
;
10994 digest
[2] -= SHA1M_C
;
10995 digest
[3] -= SHA1M_D
;
10996 digest
[4] -= SHA1M_E
;
10998 return (PARSER_OK
);
11001 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11003 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11005 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11007 if (c12
& 3) return (PARSER_HASH_VALUE
);
11009 u32
*digest
= (u32
*) hash_buf
->digest
;
11011 salt_t
*salt
= hash_buf
->salt
;
11013 // for ascii_digest
11014 salt
->salt_sign
[0] = input_buf
[0];
11015 salt
->salt_sign
[1] = input_buf
[1];
11017 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11018 | itoa64_to_int (input_buf
[1]) << 6;
11020 salt
->salt_len
= 2;
11022 u8 tmp_buf
[100] = { 0 };
11024 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11026 memcpy (digest
, tmp_buf
, 8);
11030 IP (digest
[0], digest
[1], tt
);
11035 return (PARSER_OK
);
11038 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11040 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11042 u32
*digest
= (u32
*) hash_buf
->digest
;
11044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11049 digest
[0] = byte_swap_32 (digest
[0]);
11050 digest
[1] = byte_swap_32 (digest
[1]);
11051 digest
[2] = byte_swap_32 (digest
[2]);
11052 digest
[3] = byte_swap_32 (digest
[3]);
11054 digest
[0] -= MD4M_A
;
11055 digest
[1] -= MD4M_B
;
11056 digest
[2] -= MD4M_C
;
11057 digest
[3] -= MD4M_D
;
11059 return (PARSER_OK
);
11062 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11064 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11066 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11070 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11073 u32
*digest
= (u32
*) hash_buf
->digest
;
11075 salt_t
*salt
= hash_buf
->salt
;
11077 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11078 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11079 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11080 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11082 digest
[0] = byte_swap_32 (digest
[0]);
11083 digest
[1] = byte_swap_32 (digest
[1]);
11084 digest
[2] = byte_swap_32 (digest
[2]);
11085 digest
[3] = byte_swap_32 (digest
[3]);
11087 digest
[0] -= MD4M_A
;
11088 digest
[1] -= MD4M_B
;
11089 digest
[2] -= MD4M_C
;
11090 digest
[3] -= MD4M_D
;
11092 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11094 uint salt_len
= input_len
- 32 - 1;
11096 char *salt_buf
= input_buf
+ 32 + 1;
11098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11104 salt
->salt_len
= salt_len
;
11106 return (PARSER_OK
);
11109 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11111 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11113 u32
*digest
= (u32
*) hash_buf
->digest
;
11115 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11116 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11117 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11118 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11120 digest
[0] = byte_swap_32 (digest
[0]);
11121 digest
[1] = byte_swap_32 (digest
[1]);
11122 digest
[2] = byte_swap_32 (digest
[2]);
11123 digest
[3] = byte_swap_32 (digest
[3]);
11125 digest
[0] -= MD5M_A
;
11126 digest
[1] -= MD5M_B
;
11127 digest
[2] -= MD5M_C
;
11128 digest
[3] -= MD5M_D
;
11130 return (PARSER_OK
);
11133 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11135 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11137 u32
*digest
= (u32
*) hash_buf
->digest
;
11139 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11140 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11144 digest
[0] = byte_swap_32 (digest
[0]);
11145 digest
[1] = byte_swap_32 (digest
[1]);
11147 return (PARSER_OK
);
11150 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11152 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11154 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11158 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11161 u32
*digest
= (u32
*) hash_buf
->digest
;
11163 salt_t
*salt
= hash_buf
->salt
;
11165 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11166 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11167 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11168 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11170 digest
[0] = byte_swap_32 (digest
[0]);
11171 digest
[1] = byte_swap_32 (digest
[1]);
11172 digest
[2] = byte_swap_32 (digest
[2]);
11173 digest
[3] = byte_swap_32 (digest
[3]);
11175 digest
[0] -= MD5M_A
;
11176 digest
[1] -= MD5M_B
;
11177 digest
[2] -= MD5M_C
;
11178 digest
[3] -= MD5M_D
;
11180 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11182 uint salt_len
= input_len
- 32 - 1;
11184 char *salt_buf
= input_buf
+ 32 + 1;
11186 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11188 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11192 salt
->salt_len
= salt_len
;
11194 return (PARSER_OK
);
11197 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11199 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11201 u32
*digest
= (u32
*) hash_buf
->digest
;
11203 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11204 | itoa64_to_int (input_buf
[ 1]) << 6
11205 | itoa64_to_int (input_buf
[ 2]) << 12
11206 | itoa64_to_int (input_buf
[ 3]) << 18;
11207 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11208 | itoa64_to_int (input_buf
[ 5]) << 6
11209 | itoa64_to_int (input_buf
[ 6]) << 12
11210 | itoa64_to_int (input_buf
[ 7]) << 18;
11211 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11212 | itoa64_to_int (input_buf
[ 9]) << 6
11213 | itoa64_to_int (input_buf
[10]) << 12
11214 | itoa64_to_int (input_buf
[11]) << 18;
11215 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11216 | itoa64_to_int (input_buf
[13]) << 6
11217 | itoa64_to_int (input_buf
[14]) << 12
11218 | itoa64_to_int (input_buf
[15]) << 18;
11220 digest
[0] -= MD5M_A
;
11221 digest
[1] -= MD5M_B
;
11222 digest
[2] -= MD5M_C
;
11223 digest
[3] -= MD5M_D
;
11225 digest
[0] &= 0x00ffffff;
11226 digest
[1] &= 0x00ffffff;
11227 digest
[2] &= 0x00ffffff;
11228 digest
[3] &= 0x00ffffff;
11230 return (PARSER_OK
);
11233 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11235 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11237 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11241 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11244 u32
*digest
= (u32
*) hash_buf
->digest
;
11246 salt_t
*salt
= hash_buf
->salt
;
11248 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11249 | itoa64_to_int (input_buf
[ 1]) << 6
11250 | itoa64_to_int (input_buf
[ 2]) << 12
11251 | itoa64_to_int (input_buf
[ 3]) << 18;
11252 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11253 | itoa64_to_int (input_buf
[ 5]) << 6
11254 | itoa64_to_int (input_buf
[ 6]) << 12
11255 | itoa64_to_int (input_buf
[ 7]) << 18;
11256 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11257 | itoa64_to_int (input_buf
[ 9]) << 6
11258 | itoa64_to_int (input_buf
[10]) << 12
11259 | itoa64_to_int (input_buf
[11]) << 18;
11260 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11261 | itoa64_to_int (input_buf
[13]) << 6
11262 | itoa64_to_int (input_buf
[14]) << 12
11263 | itoa64_to_int (input_buf
[15]) << 18;
11265 digest
[0] -= MD5M_A
;
11266 digest
[1] -= MD5M_B
;
11267 digest
[2] -= MD5M_C
;
11268 digest
[3] -= MD5M_D
;
11270 digest
[0] &= 0x00ffffff;
11271 digest
[1] &= 0x00ffffff;
11272 digest
[2] &= 0x00ffffff;
11273 digest
[3] &= 0x00ffffff;
11275 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11277 uint salt_len
= input_len
- 16 - 1;
11279 char *salt_buf
= input_buf
+ 16 + 1;
11281 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11283 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11285 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11287 salt
->salt_len
= salt_len
;
11289 return (PARSER_OK
);
11292 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11294 key
[0] = (nthash
[0] >> 0);
11295 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11296 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11297 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11298 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11299 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11300 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11301 key
[7] = (nthash
[6] << 1);
11313 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11315 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11317 u32
*digest
= (u32
*) hash_buf
->digest
;
11319 salt_t
*salt
= hash_buf
->salt
;
11321 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11327 char *user_pos
= input_buf
;
11329 char *unused_pos
= strchr (user_pos
, ':');
11331 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11333 uint user_len
= unused_pos
- user_pos
;
11335 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11339 char *domain_pos
= strchr (unused_pos
, ':');
11341 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11343 uint unused_len
= domain_pos
- unused_pos
;
11345 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11349 char *srvchall_pos
= strchr (domain_pos
, ':');
11351 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11353 uint domain_len
= srvchall_pos
- domain_pos
;
11355 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11359 char *hash_pos
= strchr (srvchall_pos
, ':');
11361 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11363 uint srvchall_len
= hash_pos
- srvchall_pos
;
11365 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11369 char *clichall_pos
= strchr (hash_pos
, ':');
11371 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11373 uint hash_len
= clichall_pos
- hash_pos
;
11375 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11379 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11381 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11384 * store some data for later use
11387 netntlm
->user_len
= user_len
* 2;
11388 netntlm
->domain_len
= domain_len
* 2;
11389 netntlm
->srvchall_len
= srvchall_len
/ 2;
11390 netntlm
->clichall_len
= clichall_len
/ 2;
11392 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11393 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11396 * handle username and domainname
11399 for (uint i
= 0; i
< user_len
; i
++)
11401 *userdomain_ptr
++ = user_pos
[i
];
11402 *userdomain_ptr
++ = 0;
11405 for (uint i
= 0; i
< domain_len
; i
++)
11407 *userdomain_ptr
++ = domain_pos
[i
];
11408 *userdomain_ptr
++ = 0;
11412 * handle server challenge encoding
11415 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11417 const char p0
= srvchall_pos
[i
+ 0];
11418 const char p1
= srvchall_pos
[i
+ 1];
11420 *chall_ptr
++ = hex_convert (p1
) << 0
11421 | hex_convert (p0
) << 4;
11425 * handle client challenge encoding
11428 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11430 const char p0
= clichall_pos
[i
+ 0];
11431 const char p1
= clichall_pos
[i
+ 1];
11433 *chall_ptr
++ = hex_convert (p1
) << 0
11434 | hex_convert (p0
) << 4;
11441 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11443 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11447 salt
->salt_len
= salt_len
;
11449 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11450 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11451 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11452 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11454 digest
[0] = byte_swap_32 (digest
[0]);
11455 digest
[1] = byte_swap_32 (digest
[1]);
11456 digest
[2] = byte_swap_32 (digest
[2]);
11457 digest
[3] = byte_swap_32 (digest
[3]);
11459 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11461 uint digest_tmp
[2] = { 0 };
11463 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11464 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11466 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11467 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11469 /* special case 2: ESS */
11471 if (srvchall_len
== 48)
11473 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11475 uint w
[16] = { 0 };
11477 w
[ 0] = netntlm
->chall_buf
[6];
11478 w
[ 1] = netntlm
->chall_buf
[7];
11479 w
[ 2] = netntlm
->chall_buf
[0];
11480 w
[ 3] = netntlm
->chall_buf
[1];
11484 uint dgst
[4] = { 0 };
11493 salt
->salt_buf
[0] = dgst
[0];
11494 salt
->salt_buf
[1] = dgst
[1];
11498 /* precompute netntlmv1 exploit start */
11500 for (uint i
= 0; i
< 0x10000; i
++)
11502 uint key_md4
[2] = { i
, 0 };
11503 uint key_des
[2] = { 0, 0 };
11505 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11507 uint Kc
[16] = { 0 };
11508 uint Kd
[16] = { 0 };
11510 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11512 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11514 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11516 if (data3
[0] != digest_tmp
[0]) continue;
11517 if (data3
[1] != digest_tmp
[1]) continue;
11519 salt
->salt_buf
[2] = i
;
11521 salt
->salt_len
= 24;
11526 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11527 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11529 /* precompute netntlmv1 exploit stop */
11533 IP (digest
[0], digest
[1], tt
);
11534 IP (digest
[2], digest
[3], tt
);
11536 digest
[0] = rotr32 (digest
[0], 29);
11537 digest
[1] = rotr32 (digest
[1], 29);
11538 digest
[2] = rotr32 (digest
[2], 29);
11539 digest
[3] = rotr32 (digest
[3], 29);
11541 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11543 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11544 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11546 return (PARSER_OK
);
11549 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11551 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11553 u32
*digest
= (u32
*) hash_buf
->digest
;
11555 salt_t
*salt
= hash_buf
->salt
;
11557 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11563 char *user_pos
= input_buf
;
11565 char *unused_pos
= strchr (user_pos
, ':');
11567 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11569 uint user_len
= unused_pos
- user_pos
;
11571 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11575 char *domain_pos
= strchr (unused_pos
, ':');
11577 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11579 uint unused_len
= domain_pos
- unused_pos
;
11581 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11585 char *srvchall_pos
= strchr (domain_pos
, ':');
11587 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11589 uint domain_len
= srvchall_pos
- domain_pos
;
11591 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11595 char *hash_pos
= strchr (srvchall_pos
, ':');
11597 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11599 uint srvchall_len
= hash_pos
- srvchall_pos
;
11601 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11605 char *clichall_pos
= strchr (hash_pos
, ':');
11607 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11609 uint hash_len
= clichall_pos
- hash_pos
;
11611 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11615 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11617 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11619 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11622 * store some data for later use
11625 netntlm
->user_len
= user_len
* 2;
11626 netntlm
->domain_len
= domain_len
* 2;
11627 netntlm
->srvchall_len
= srvchall_len
/ 2;
11628 netntlm
->clichall_len
= clichall_len
/ 2;
11630 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11631 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11634 * handle username and domainname
11637 for (uint i
= 0; i
< user_len
; i
++)
11639 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11640 *userdomain_ptr
++ = 0;
11643 for (uint i
= 0; i
< domain_len
; i
++)
11645 *userdomain_ptr
++ = domain_pos
[i
];
11646 *userdomain_ptr
++ = 0;
11649 *userdomain_ptr
++ = 0x80;
11652 * handle server challenge encoding
11655 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11657 const char p0
= srvchall_pos
[i
+ 0];
11658 const char p1
= srvchall_pos
[i
+ 1];
11660 *chall_ptr
++ = hex_convert (p1
) << 0
11661 | hex_convert (p0
) << 4;
11665 * handle client challenge encoding
11668 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11670 const char p0
= clichall_pos
[i
+ 0];
11671 const char p1
= clichall_pos
[i
+ 1];
11673 *chall_ptr
++ = hex_convert (p1
) << 0
11674 | hex_convert (p0
) << 4;
11677 *chall_ptr
++ = 0x80;
11680 * handle hash itself
11683 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11684 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11685 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11686 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11688 digest
[0] = byte_swap_32 (digest
[0]);
11689 digest
[1] = byte_swap_32 (digest
[1]);
11690 digest
[2] = byte_swap_32 (digest
[2]);
11691 digest
[3] = byte_swap_32 (digest
[3]);
11694 * reuse challange data as salt_buf, its the buffer that is most likely unique
11697 salt
->salt_buf
[0] = 0;
11698 salt
->salt_buf
[1] = 0;
11699 salt
->salt_buf
[2] = 0;
11700 salt
->salt_buf
[3] = 0;
11701 salt
->salt_buf
[4] = 0;
11702 salt
->salt_buf
[5] = 0;
11703 salt
->salt_buf
[6] = 0;
11704 salt
->salt_buf
[7] = 0;
11708 uptr
= (uint
*) netntlm
->userdomain_buf
;
11710 for (uint i
= 0; i
< 16; i
+= 16)
11712 md5_64 (uptr
, salt
->salt_buf
);
11715 uptr
= (uint
*) netntlm
->chall_buf
;
11717 for (uint i
= 0; i
< 256; i
+= 16)
11719 md5_64 (uptr
, salt
->salt_buf
);
11722 salt
->salt_len
= 16;
11724 return (PARSER_OK
);
11727 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11729 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11731 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11735 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11738 u32
*digest
= (u32
*) hash_buf
->digest
;
11740 salt_t
*salt
= hash_buf
->salt
;
11742 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11743 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11744 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11745 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11747 digest
[0] = byte_swap_32 (digest
[0]);
11748 digest
[1] = byte_swap_32 (digest
[1]);
11749 digest
[2] = byte_swap_32 (digest
[2]);
11750 digest
[3] = byte_swap_32 (digest
[3]);
11752 digest
[0] -= MD5M_A
;
11753 digest
[1] -= MD5M_B
;
11754 digest
[2] -= MD5M_C
;
11755 digest
[3] -= MD5M_D
;
11757 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11759 uint salt_len
= input_len
- 32 - 1;
11761 char *salt_buf
= input_buf
+ 32 + 1;
11763 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11765 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11767 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11769 salt
->salt_len
= salt_len
;
11771 return (PARSER_OK
);
11774 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11776 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11778 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11782 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11785 u32
*digest
= (u32
*) hash_buf
->digest
;
11787 salt_t
*salt
= hash_buf
->salt
;
11789 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11790 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11791 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11792 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11794 digest
[0] = byte_swap_32 (digest
[0]);
11795 digest
[1] = byte_swap_32 (digest
[1]);
11796 digest
[2] = byte_swap_32 (digest
[2]);
11797 digest
[3] = byte_swap_32 (digest
[3]);
11799 digest
[0] -= MD5M_A
;
11800 digest
[1] -= MD5M_B
;
11801 digest
[2] -= MD5M_C
;
11802 digest
[3] -= MD5M_D
;
11804 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11806 uint salt_len
= input_len
- 32 - 1;
11808 char *salt_buf
= input_buf
+ 32 + 1;
11810 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11812 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11814 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11816 salt
->salt_len
= salt_len
;
11818 return (PARSER_OK
);
11821 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11823 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11825 u32
*digest
= (u32
*) hash_buf
->digest
;
11827 salt_t
*salt
= hash_buf
->salt
;
11829 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11830 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11831 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11832 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11834 digest
[0] = byte_swap_32 (digest
[0]);
11835 digest
[1] = byte_swap_32 (digest
[1]);
11836 digest
[2] = byte_swap_32 (digest
[2]);
11837 digest
[3] = byte_swap_32 (digest
[3]);
11839 digest
[0] -= MD5M_A
;
11840 digest
[1] -= MD5M_B
;
11841 digest
[2] -= MD5M_C
;
11842 digest
[3] -= MD5M_D
;
11845 * This is a virtual salt. While the algorithm is basically not salted
11846 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11847 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11852 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11856 salt
->salt_len
= salt_len
;
11858 return (PARSER_OK
);
11861 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11863 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11865 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11869 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11872 u32
*digest
= (u32
*) hash_buf
->digest
;
11874 salt_t
*salt
= hash_buf
->salt
;
11876 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11877 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11878 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11879 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11881 digest
[0] = byte_swap_32 (digest
[0]);
11882 digest
[1] = byte_swap_32 (digest
[1]);
11883 digest
[2] = byte_swap_32 (digest
[2]);
11884 digest
[3] = byte_swap_32 (digest
[3]);
11886 digest
[0] -= MD5M_A
;
11887 digest
[1] -= MD5M_B
;
11888 digest
[2] -= MD5M_C
;
11889 digest
[3] -= MD5M_D
;
11891 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11893 uint salt_len
= input_len
- 32 - 1;
11895 char *salt_buf
= input_buf
+ 32 + 1;
11897 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11899 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11901 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11903 salt
->salt_len
= salt_len
;
11905 return (PARSER_OK
);
11908 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11910 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11912 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11916 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11919 u32
*digest
= (u32
*) hash_buf
->digest
;
11921 salt_t
*salt
= hash_buf
->salt
;
11923 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11924 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11925 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11926 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11928 digest
[0] = byte_swap_32 (digest
[0]);
11929 digest
[1] = byte_swap_32 (digest
[1]);
11930 digest
[2] = byte_swap_32 (digest
[2]);
11931 digest
[3] = byte_swap_32 (digest
[3]);
11933 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11935 uint salt_len
= input_len
- 32 - 1;
11937 char *salt_buf
= input_buf
+ 32 + 1;
11939 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11941 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11943 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11945 salt
->salt_len
= salt_len
;
11947 return (PARSER_OK
);
11950 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11952 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11954 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11958 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11961 u32
*digest
= (u32
*) hash_buf
->digest
;
11963 salt_t
*salt
= hash_buf
->salt
;
11965 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11966 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11967 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11968 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11970 digest
[0] = byte_swap_32 (digest
[0]);
11971 digest
[1] = byte_swap_32 (digest
[1]);
11972 digest
[2] = byte_swap_32 (digest
[2]);
11973 digest
[3] = byte_swap_32 (digest
[3]);
11975 digest
[0] -= MD4M_A
;
11976 digest
[1] -= MD4M_B
;
11977 digest
[2] -= MD4M_C
;
11978 digest
[3] -= MD4M_D
;
11980 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11982 uint salt_len
= input_len
- 32 - 1;
11984 char *salt_buf
= input_buf
+ 32 + 1;
11986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11988 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11992 salt
->salt_len
= salt_len
;
11994 return (PARSER_OK
);
11997 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11999 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12001 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12005 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12008 u32
*digest
= (u32
*) hash_buf
->digest
;
12010 salt_t
*salt
= hash_buf
->salt
;
12012 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12013 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12014 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12015 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12017 digest
[0] = byte_swap_32 (digest
[0]);
12018 digest
[1] = byte_swap_32 (digest
[1]);
12019 digest
[2] = byte_swap_32 (digest
[2]);
12020 digest
[3] = byte_swap_32 (digest
[3]);
12022 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12024 uint salt_len
= input_len
- 32 - 1;
12026 char *salt_buf
= input_buf
+ 32 + 1;
12028 uint salt_pc_block
[16] = { 0 };
12030 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12032 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12036 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12038 salt_pc_block
[14] = salt_len
* 8;
12040 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12042 md5_64 (salt_pc_block
, salt_pc_digest
);
12044 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12045 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12046 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12047 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12049 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12051 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12053 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12055 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12056 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12057 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12058 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12060 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12062 return (PARSER_OK
);
12065 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12067 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12069 u32
*digest
= (u32
*) hash_buf
->digest
;
12071 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12072 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12073 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12074 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12075 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12077 digest
[0] -= SHA1M_A
;
12078 digest
[1] -= SHA1M_B
;
12079 digest
[2] -= SHA1M_C
;
12080 digest
[3] -= SHA1M_D
;
12081 digest
[4] -= SHA1M_E
;
12083 return (PARSER_OK
);
12086 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12088 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12090 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12092 u32
*digest
= (u32
*) hash_buf
->digest
;
12096 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12097 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12098 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12099 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12102 return (PARSER_OK
);
12105 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12107 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12109 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12113 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12116 u32
*digest
= (u32
*) hash_buf
->digest
;
12118 salt_t
*salt
= hash_buf
->salt
;
12120 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12121 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12122 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12123 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12124 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12126 digest
[0] -= SHA1M_A
;
12127 digest
[1] -= SHA1M_B
;
12128 digest
[2] -= SHA1M_C
;
12129 digest
[3] -= SHA1M_D
;
12130 digest
[4] -= SHA1M_E
;
12132 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12134 uint salt_len
= input_len
- 40 - 1;
12136 char *salt_buf
= input_buf
+ 40 + 1;
12138 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12140 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12142 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12144 salt
->salt_len
= salt_len
;
12146 return (PARSER_OK
);
12149 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12151 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12153 u32
*digest
= (u32
*) hash_buf
->digest
;
12155 salt_t
*salt
= hash_buf
->salt
;
12157 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12159 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12160 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12161 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12162 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12163 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12165 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12167 uint salt_len
= input_len
- 40 - 1;
12169 char *salt_buf
= input_buf
+ 40 + 1;
12171 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12173 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12175 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12177 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12180 pstoken
->salt_len
= salt_len
/ 2;
12182 /* some fake salt for the sorting mechanisms */
12184 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12185 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12186 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12187 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12188 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12189 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12190 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12191 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12193 salt
->salt_len
= 32;
12195 /* we need to check if we can precompute some of the data --
12196 this is possible since the scheme is badly designed */
12198 pstoken
->pc_digest
[0] = SHA1M_A
;
12199 pstoken
->pc_digest
[1] = SHA1M_B
;
12200 pstoken
->pc_digest
[2] = SHA1M_C
;
12201 pstoken
->pc_digest
[3] = SHA1M_D
;
12202 pstoken
->pc_digest
[4] = SHA1M_E
;
12204 pstoken
->pc_offset
= 0;
12206 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12210 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12211 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12212 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12213 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12214 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12215 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12216 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12217 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12218 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12219 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12220 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12221 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12222 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12223 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12224 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12225 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12227 sha1_64 (w
, pstoken
->pc_digest
);
12229 pstoken
->pc_offset
+= 16;
12232 return (PARSER_OK
);
12235 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12237 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12239 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12241 u32
*digest
= (u32
*) hash_buf
->digest
;
12243 u8 tmp_buf
[100] = { 0 };
12245 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12247 memcpy (digest
, tmp_buf
, 20);
12249 digest
[0] = byte_swap_32 (digest
[0]);
12250 digest
[1] = byte_swap_32 (digest
[1]);
12251 digest
[2] = byte_swap_32 (digest
[2]);
12252 digest
[3] = byte_swap_32 (digest
[3]);
12253 digest
[4] = byte_swap_32 (digest
[4]);
12255 digest
[0] -= SHA1M_A
;
12256 digest
[1] -= SHA1M_B
;
12257 digest
[2] -= SHA1M_C
;
12258 digest
[3] -= SHA1M_D
;
12259 digest
[4] -= SHA1M_E
;
12261 return (PARSER_OK
);
12264 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12266 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12268 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12270 u32
*digest
= (u32
*) hash_buf
->digest
;
12272 salt_t
*salt
= hash_buf
->salt
;
12274 u8 tmp_buf
[100] = { 0 };
12276 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12278 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12280 memcpy (digest
, tmp_buf
, 20);
12282 int salt_len
= tmp_len
- 20;
12284 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12286 salt
->salt_len
= salt_len
;
12288 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12290 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12292 char *ptr
= (char *) salt
->salt_buf
;
12294 ptr
[salt
->salt_len
] = 0x80;
12297 digest
[0] = byte_swap_32 (digest
[0]);
12298 digest
[1] = byte_swap_32 (digest
[1]);
12299 digest
[2] = byte_swap_32 (digest
[2]);
12300 digest
[3] = byte_swap_32 (digest
[3]);
12301 digest
[4] = byte_swap_32 (digest
[4]);
12303 digest
[0] -= SHA1M_A
;
12304 digest
[1] -= SHA1M_B
;
12305 digest
[2] -= SHA1M_C
;
12306 digest
[3] -= SHA1M_D
;
12307 digest
[4] -= SHA1M_E
;
12309 return (PARSER_OK
);
12312 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12314 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12316 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12318 u32
*digest
= (u32
*) hash_buf
->digest
;
12320 salt_t
*salt
= hash_buf
->salt
;
12322 char *salt_buf
= input_buf
+ 6;
12326 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12328 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12330 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12332 salt
->salt_len
= salt_len
;
12334 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12336 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12337 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12338 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12339 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12340 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12342 digest
[0] -= SHA1M_A
;
12343 digest
[1] -= SHA1M_B
;
12344 digest
[2] -= SHA1M_C
;
12345 digest
[3] -= SHA1M_D
;
12346 digest
[4] -= SHA1M_E
;
12348 return (PARSER_OK
);
12351 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12353 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12355 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12357 u32
*digest
= (u32
*) hash_buf
->digest
;
12359 salt_t
*salt
= hash_buf
->salt
;
12361 char *salt_buf
= input_buf
+ 6;
12365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12371 salt
->salt_len
= salt_len
;
12373 char *hash_pos
= input_buf
+ 6 + 8;
12375 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12376 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12377 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12378 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12379 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12381 digest
[0] -= SHA1M_A
;
12382 digest
[1] -= SHA1M_B
;
12383 digest
[2] -= SHA1M_C
;
12384 digest
[3] -= SHA1M_D
;
12385 digest
[4] -= SHA1M_E
;
12387 return (PARSER_OK
);
12390 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12392 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12394 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12396 u64
*digest
= (u64
*) hash_buf
->digest
;
12398 salt_t
*salt
= hash_buf
->salt
;
12400 char *salt_buf
= input_buf
+ 6;
12404 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12406 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12408 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12410 salt
->salt_len
= salt_len
;
12412 char *hash_pos
= input_buf
+ 6 + 8;
12414 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12415 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12416 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12417 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12418 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12419 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12420 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12421 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12423 digest
[0] -= SHA512M_A
;
12424 digest
[1] -= SHA512M_B
;
12425 digest
[2] -= SHA512M_C
;
12426 digest
[3] -= SHA512M_D
;
12427 digest
[4] -= SHA512M_E
;
12428 digest
[5] -= SHA512M_F
;
12429 digest
[6] -= SHA512M_G
;
12430 digest
[7] -= SHA512M_H
;
12432 return (PARSER_OK
);
12435 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12437 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12439 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12443 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12446 u32
*digest
= (u32
*) hash_buf
->digest
;
12448 salt_t
*salt
= hash_buf
->salt
;
12450 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12451 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12455 digest
[0] = byte_swap_32 (digest
[0]);
12456 digest
[1] = byte_swap_32 (digest
[1]);
12458 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12460 uint salt_len
= input_len
- 16 - 1;
12462 char *salt_buf
= input_buf
+ 16 + 1;
12464 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12466 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12468 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12470 salt
->salt_len
= salt_len
;
12472 return (PARSER_OK
);
12475 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12477 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12479 u32
*digest
= (u32
*) hash_buf
->digest
;
12481 salt_t
*salt
= hash_buf
->salt
;
12483 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12484 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12485 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12486 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12487 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12489 digest
[0] -= SHA1M_A
;
12490 digest
[1] -= SHA1M_B
;
12491 digest
[2] -= SHA1M_C
;
12492 digest
[3] -= SHA1M_D
;
12493 digest
[4] -= SHA1M_E
;
12495 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12497 uint salt_len
= input_len
- 40 - 1;
12499 char *salt_buf
= input_buf
+ 40 + 1;
12501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12503 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12507 salt
->salt_len
= salt_len
;
12509 return (PARSER_OK
);
12512 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12514 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12516 u32
*digest
= (u32
*) hash_buf
->digest
;
12518 salt_t
*salt
= hash_buf
->salt
;
12520 char *hash_pos
= input_buf
;
12522 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12523 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12524 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12525 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12526 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12527 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12528 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12529 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12530 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12531 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12532 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12533 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12534 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12535 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12536 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12537 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12539 char *salt_pos
= input_buf
+ 128;
12541 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12542 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12543 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12544 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12546 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12547 salt
->salt_len
= 16;
12549 return (PARSER_OK
);
12552 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12554 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12556 u32
*digest
= (u32
*) hash_buf
->digest
;
12558 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12559 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12560 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12561 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12562 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12563 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12564 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12565 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12567 digest
[0] -= SHA256M_A
;
12568 digest
[1] -= SHA256M_B
;
12569 digest
[2] -= SHA256M_C
;
12570 digest
[3] -= SHA256M_D
;
12571 digest
[4] -= SHA256M_E
;
12572 digest
[5] -= SHA256M_F
;
12573 digest
[6] -= SHA256M_G
;
12574 digest
[7] -= SHA256M_H
;
12576 return (PARSER_OK
);
12579 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12581 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12583 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12587 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12590 u32
*digest
= (u32
*) hash_buf
->digest
;
12592 salt_t
*salt
= hash_buf
->salt
;
12594 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12595 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12596 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12597 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12598 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12599 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12600 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12601 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12603 digest
[0] -= SHA256M_A
;
12604 digest
[1] -= SHA256M_B
;
12605 digest
[2] -= SHA256M_C
;
12606 digest
[3] -= SHA256M_D
;
12607 digest
[4] -= SHA256M_E
;
12608 digest
[5] -= SHA256M_F
;
12609 digest
[6] -= SHA256M_G
;
12610 digest
[7] -= SHA256M_H
;
12612 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12614 uint salt_len
= input_len
- 64 - 1;
12616 char *salt_buf
= input_buf
+ 64 + 1;
12618 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12620 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12622 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12624 salt
->salt_len
= salt_len
;
12626 return (PARSER_OK
);
12629 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12631 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12633 u64
*digest
= (u64
*) hash_buf
->digest
;
12635 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12636 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12637 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12638 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12639 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12640 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12644 digest
[0] -= SHA384M_A
;
12645 digest
[1] -= SHA384M_B
;
12646 digest
[2] -= SHA384M_C
;
12647 digest
[3] -= SHA384M_D
;
12648 digest
[4] -= SHA384M_E
;
12649 digest
[5] -= SHA384M_F
;
12653 return (PARSER_OK
);
12656 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12658 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12660 u64
*digest
= (u64
*) hash_buf
->digest
;
12662 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12663 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12664 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12665 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12666 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12667 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12668 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12669 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12671 digest
[0] -= SHA512M_A
;
12672 digest
[1] -= SHA512M_B
;
12673 digest
[2] -= SHA512M_C
;
12674 digest
[3] -= SHA512M_D
;
12675 digest
[4] -= SHA512M_E
;
12676 digest
[5] -= SHA512M_F
;
12677 digest
[6] -= SHA512M_G
;
12678 digest
[7] -= SHA512M_H
;
12680 return (PARSER_OK
);
12683 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12685 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12687 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12691 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12694 u64
*digest
= (u64
*) hash_buf
->digest
;
12696 salt_t
*salt
= hash_buf
->salt
;
12698 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12699 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12700 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12701 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12702 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12703 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12704 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12705 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12707 digest
[0] -= SHA512M_A
;
12708 digest
[1] -= SHA512M_B
;
12709 digest
[2] -= SHA512M_C
;
12710 digest
[3] -= SHA512M_D
;
12711 digest
[4] -= SHA512M_E
;
12712 digest
[5] -= SHA512M_F
;
12713 digest
[6] -= SHA512M_G
;
12714 digest
[7] -= SHA512M_H
;
12716 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12718 uint salt_len
= input_len
- 128 - 1;
12720 char *salt_buf
= input_buf
+ 128 + 1;
12722 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12724 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12726 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12728 salt
->salt_len
= salt_len
;
12730 return (PARSER_OK
);
12733 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12735 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12737 u64
*digest
= (u64
*) hash_buf
->digest
;
12739 salt_t
*salt
= hash_buf
->salt
;
12741 char *salt_pos
= input_buf
+ 3;
12743 uint iterations_len
= 0;
12745 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12749 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12751 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12752 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12756 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12760 iterations_len
+= 8;
12764 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12767 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12769 char *hash_pos
= strchr (salt_pos
, '$');
12771 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12773 uint salt_len
= hash_pos
- salt_pos
;
12775 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12777 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12779 salt
->salt_len
= salt_len
;
12783 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12785 return (PARSER_OK
);
12788 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12790 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12792 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12794 u64
*digest
= (u64
*) hash_buf
->digest
;
12796 salt_t
*salt
= hash_buf
->salt
;
12798 uint keccak_mdlen
= input_len
/ 2;
12800 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12802 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12804 digest
[i
] = byte_swap_64 (digest
[i
]);
12807 salt
->keccak_mdlen
= keccak_mdlen
;
12809 return (PARSER_OK
);
12812 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12814 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12816 u32
*digest
= (u32
*) hash_buf
->digest
;
12818 salt_t
*salt
= hash_buf
->salt
;
12820 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12823 * Parse that strange long line
12828 size_t in_len
[9] = { 0 };
12830 in_off
[0] = strtok (input_buf
, ":");
12832 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12834 in_len
[0] = strlen (in_off
[0]);
12838 for (i
= 1; i
< 9; i
++)
12840 in_off
[i
] = strtok (NULL
, ":");
12842 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12844 in_len
[i
] = strlen (in_off
[i
]);
12847 char *ptr
= (char *) ikepsk
->msg_buf
;
12849 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12850 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12851 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12852 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12853 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12854 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12858 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12860 ptr
= (char *) ikepsk
->nr_buf
;
12862 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12863 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12867 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12870 * Store to database
12875 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12876 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12877 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12878 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12880 digest
[0] = byte_swap_32 (digest
[0]);
12881 digest
[1] = byte_swap_32 (digest
[1]);
12882 digest
[2] = byte_swap_32 (digest
[2]);
12883 digest
[3] = byte_swap_32 (digest
[3]);
12885 salt
->salt_len
= 32;
12887 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12888 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12889 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12890 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12891 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12892 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12893 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12894 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12896 return (PARSER_OK
);
12899 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12901 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12903 u32
*digest
= (u32
*) hash_buf
->digest
;
12905 salt_t
*salt
= hash_buf
->salt
;
12907 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12910 * Parse that strange long line
12915 size_t in_len
[9] = { 0 };
12917 in_off
[0] = strtok (input_buf
, ":");
12919 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12921 in_len
[0] = strlen (in_off
[0]);
12925 for (i
= 1; i
< 9; i
++)
12927 in_off
[i
] = strtok (NULL
, ":");
12929 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12931 in_len
[i
] = strlen (in_off
[i
]);
12934 char *ptr
= (char *) ikepsk
->msg_buf
;
12936 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12937 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12938 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12939 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12940 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12941 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12945 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12947 ptr
= (char *) ikepsk
->nr_buf
;
12949 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12950 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12954 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12957 * Store to database
12962 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12963 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12964 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12965 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12966 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12968 salt
->salt_len
= 32;
12970 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12971 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12972 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12973 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12974 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12975 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12976 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12977 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12979 return (PARSER_OK
);
12982 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12984 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12986 u32
*digest
= (u32
*) hash_buf
->digest
;
12988 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12989 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12990 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12991 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12992 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12994 digest
[0] = byte_swap_32 (digest
[0]);
12995 digest
[1] = byte_swap_32 (digest
[1]);
12996 digest
[2] = byte_swap_32 (digest
[2]);
12997 digest
[3] = byte_swap_32 (digest
[3]);
12998 digest
[4] = byte_swap_32 (digest
[4]);
13000 return (PARSER_OK
);
13003 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13005 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13007 u32
*digest
= (u32
*) hash_buf
->digest
;
13009 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13010 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13011 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13012 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13013 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13014 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13015 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13016 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13017 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13018 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13019 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13020 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13021 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13022 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13023 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13024 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13026 return (PARSER_OK
);
13029 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13031 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13033 u32
*digest
= (u32
*) hash_buf
->digest
;
13035 salt_t
*salt
= hash_buf
->salt
;
13037 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13038 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13039 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13040 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13041 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13043 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13045 uint salt_len
= input_len
- 40 - 1;
13047 char *salt_buf
= input_buf
+ 40 + 1;
13049 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13051 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13053 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13055 salt
->salt_len
= salt_len
;
13057 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13059 return (PARSER_OK
);
13062 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13064 u32
*digest
= (u32
*) hash_buf
->digest
;
13066 salt_t
*salt
= hash_buf
->salt
;
13068 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13070 if (input_len
== 0)
13072 log_error ("TrueCrypt container not specified");
13077 FILE *fp
= fopen (input_buf
, "rb");
13081 log_error ("%s: %s", input_buf
, strerror (errno
));
13086 char buf
[512] = { 0 };
13088 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13092 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13094 memcpy (tc
->salt_buf
, buf
, 64);
13096 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13098 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13100 salt
->salt_len
= 4;
13102 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13104 tc
->signature
= 0x45555254; // "TRUE"
13106 digest
[0] = tc
->data_buf
[0];
13108 return (PARSER_OK
);
13111 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13113 u32
*digest
= (u32
*) hash_buf
->digest
;
13115 salt_t
*salt
= hash_buf
->salt
;
13117 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13119 if (input_len
== 0)
13121 log_error ("TrueCrypt container not specified");
13126 FILE *fp
= fopen (input_buf
, "rb");
13130 log_error ("%s: %s", input_buf
, strerror (errno
));
13135 char buf
[512] = { 0 };
13137 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13141 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13143 memcpy (tc
->salt_buf
, buf
, 64);
13145 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13147 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13149 salt
->salt_len
= 4;
13151 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13153 tc
->signature
= 0x45555254; // "TRUE"
13155 digest
[0] = tc
->data_buf
[0];
13157 return (PARSER_OK
);
13160 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13162 u32
*digest
= (u32
*) hash_buf
->digest
;
13164 salt_t
*salt
= hash_buf
->salt
;
13166 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13168 if (input_len
== 0)
13170 log_error ("VeraCrypt container not specified");
13175 FILE *fp
= fopen (input_buf
, "rb");
13179 log_error ("%s: %s", input_buf
, strerror (errno
));
13184 char buf
[512] = { 0 };
13186 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13190 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13192 memcpy (tc
->salt_buf
, buf
, 64);
13194 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13196 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13198 salt
->salt_len
= 4;
13200 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13202 tc
->signature
= 0x41524556; // "VERA"
13204 digest
[0] = tc
->data_buf
[0];
13206 return (PARSER_OK
);
13209 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13211 u32
*digest
= (u32
*) hash_buf
->digest
;
13213 salt_t
*salt
= hash_buf
->salt
;
13215 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13217 if (input_len
== 0)
13219 log_error ("VeraCrypt container not specified");
13224 FILE *fp
= fopen (input_buf
, "rb");
13228 log_error ("%s: %s", input_buf
, strerror (errno
));
13233 char buf
[512] = { 0 };
13235 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13239 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13241 memcpy (tc
->salt_buf
, buf
, 64);
13243 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13245 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13247 salt
->salt_len
= 4;
13249 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13251 tc
->signature
= 0x41524556; // "VERA"
13253 digest
[0] = tc
->data_buf
[0];
13255 return (PARSER_OK
);
13258 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13260 u32
*digest
= (u32
*) hash_buf
->digest
;
13262 salt_t
*salt
= hash_buf
->salt
;
13264 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13266 if (input_len
== 0)
13268 log_error ("VeraCrypt container not specified");
13273 FILE *fp
= fopen (input_buf
, "rb");
13277 log_error ("%s: %s", input_buf
, strerror (errno
));
13282 char buf
[512] = { 0 };
13284 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13288 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13290 memcpy (tc
->salt_buf
, buf
, 64);
13292 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13294 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13296 salt
->salt_len
= 4;
13298 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13300 tc
->signature
= 0x41524556; // "VERA"
13302 digest
[0] = tc
->data_buf
[0];
13304 return (PARSER_OK
);
13307 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13309 u32
*digest
= (u32
*) hash_buf
->digest
;
13311 salt_t
*salt
= hash_buf
->salt
;
13313 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13315 if (input_len
== 0)
13317 log_error ("VeraCrypt container not specified");
13322 FILE *fp
= fopen (input_buf
, "rb");
13326 log_error ("%s: %s", input_buf
, strerror (errno
));
13331 char buf
[512] = { 0 };
13333 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13337 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13339 memcpy (tc
->salt_buf
, buf
, 64);
13341 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13343 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13345 salt
->salt_len
= 4;
13347 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13349 tc
->signature
= 0x41524556; // "VERA"
13351 digest
[0] = tc
->data_buf
[0];
13353 return (PARSER_OK
);
13356 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13358 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13360 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13362 u32
*digest
= (u32
*) hash_buf
->digest
;
13364 salt_t
*salt
= hash_buf
->salt
;
13366 char *salt_pos
= input_buf
+ 6;
13368 char *hash_pos
= strchr (salt_pos
, '$');
13370 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13372 uint salt_len
= hash_pos
- salt_pos
;
13374 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13376 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13378 salt
->salt_len
= salt_len
;
13380 salt
->salt_iter
= 1000;
13384 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13386 return (PARSER_OK
);
13389 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13391 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13393 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13395 u32
*digest
= (u32
*) hash_buf
->digest
;
13397 salt_t
*salt
= hash_buf
->salt
;
13399 char *iter_pos
= input_buf
+ 7;
13401 char *salt_pos
= strchr (iter_pos
, '$');
13403 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13407 char *hash_pos
= strchr (salt_pos
, '$');
13409 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13411 uint salt_len
= hash_pos
- salt_pos
;
13413 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13415 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13417 salt
->salt_len
= salt_len
;
13419 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13421 salt
->salt_sign
[0] = atoi (salt_iter
);
13423 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13427 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13429 digest
[0] = byte_swap_32 (digest
[0]);
13430 digest
[1] = byte_swap_32 (digest
[1]);
13431 digest
[2] = byte_swap_32 (digest
[2]);
13432 digest
[3] = byte_swap_32 (digest
[3]);
13433 digest
[4] = byte_swap_32 (digest
[4]);
13435 return (PARSER_OK
);
13438 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13440 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13442 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13444 u32
*digest
= (u32
*) hash_buf
->digest
;
13446 salt_t
*salt
= hash_buf
->salt
;
13448 char *iter_pos
= input_buf
+ 9;
13450 char *salt_pos
= strchr (iter_pos
, '$');
13452 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13456 char *hash_pos
= strchr (salt_pos
, '$');
13458 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13460 uint salt_len
= hash_pos
- salt_pos
;
13462 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13464 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13466 salt
->salt_len
= salt_len
;
13468 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13470 salt
->salt_sign
[0] = atoi (salt_iter
);
13472 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13476 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13478 digest
[0] = byte_swap_32 (digest
[0]);
13479 digest
[1] = byte_swap_32 (digest
[1]);
13480 digest
[2] = byte_swap_32 (digest
[2]);
13481 digest
[3] = byte_swap_32 (digest
[3]);
13482 digest
[4] = byte_swap_32 (digest
[4]);
13483 digest
[5] = byte_swap_32 (digest
[5]);
13484 digest
[6] = byte_swap_32 (digest
[6]);
13485 digest
[7] = byte_swap_32 (digest
[7]);
13487 return (PARSER_OK
);
13490 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13492 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13494 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13496 u64
*digest
= (u64
*) hash_buf
->digest
;
13498 salt_t
*salt
= hash_buf
->salt
;
13500 char *iter_pos
= input_buf
+ 9;
13502 char *salt_pos
= strchr (iter_pos
, '$');
13504 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13508 char *hash_pos
= strchr (salt_pos
, '$');
13510 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13512 uint salt_len
= hash_pos
- salt_pos
;
13514 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13516 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13518 salt
->salt_len
= salt_len
;
13520 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13522 salt
->salt_sign
[0] = atoi (salt_iter
);
13524 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13528 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13530 digest
[0] = byte_swap_64 (digest
[0]);
13531 digest
[1] = byte_swap_64 (digest
[1]);
13532 digest
[2] = byte_swap_64 (digest
[2]);
13533 digest
[3] = byte_swap_64 (digest
[3]);
13534 digest
[4] = byte_swap_64 (digest
[4]);
13535 digest
[5] = byte_swap_64 (digest
[5]);
13536 digest
[6] = byte_swap_64 (digest
[6]);
13537 digest
[7] = byte_swap_64 (digest
[7]);
13539 return (PARSER_OK
);
13542 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13544 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13546 u32
*digest
= (u32
*) hash_buf
->digest
;
13548 salt_t
*salt
= hash_buf
->salt
;
13550 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13556 char *iterations_pos
= input_buf
;
13558 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13560 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13562 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13564 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13568 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13570 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13572 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13574 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13576 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13578 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13583 * pbkdf2 iterations
13586 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13589 * handle salt encoding
13592 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13594 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13596 const char p0
= saltbuf_pos
[i
+ 0];
13597 const char p1
= saltbuf_pos
[i
+ 1];
13599 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13600 | hex_convert (p0
) << 4;
13603 salt
->salt_len
= saltbuf_len
/ 2;
13606 * handle cipher encoding
13609 uint
*tmp
= (uint
*) mymalloc (32);
13611 char *cipherbuf_ptr
= (char *) tmp
;
13613 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13615 const char p0
= cipherbuf_pos
[i
+ 0];
13616 const char p1
= cipherbuf_pos
[i
+ 1];
13618 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13619 | hex_convert (p0
) << 4;
13622 // iv is stored at salt_buf 4 (length 16)
13623 // data is stored at salt_buf 8 (length 16)
13625 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13626 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13627 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13628 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13630 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13631 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13632 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13633 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13637 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13639 const char p0
= cipherbuf_pos
[j
+ 0];
13640 const char p1
= cipherbuf_pos
[j
+ 1];
13642 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13643 | hex_convert (p0
) << 4;
13650 digest
[0] = 0x10101010;
13651 digest
[1] = 0x10101010;
13652 digest
[2] = 0x10101010;
13653 digest
[3] = 0x10101010;
13655 return (PARSER_OK
);
13658 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13660 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13662 u32
*digest
= (u32
*) hash_buf
->digest
;
13664 salt_t
*salt
= hash_buf
->salt
;
13666 char *hashbuf_pos
= input_buf
;
13668 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13670 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13672 uint hash_len
= iterations_pos
- hashbuf_pos
;
13674 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13678 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13680 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13682 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13686 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13688 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13690 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13692 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13694 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13696 salt
->salt_len
= salt_len
;
13698 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13700 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13701 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13702 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13703 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13705 return (PARSER_OK
);
13708 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13710 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13712 u32
*digest
= (u32
*) hash_buf
->digest
;
13714 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13715 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13716 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13717 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13718 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13719 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13720 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13721 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13723 digest
[0] = byte_swap_32 (digest
[0]);
13724 digest
[1] = byte_swap_32 (digest
[1]);
13725 digest
[2] = byte_swap_32 (digest
[2]);
13726 digest
[3] = byte_swap_32 (digest
[3]);
13727 digest
[4] = byte_swap_32 (digest
[4]);
13728 digest
[5] = byte_swap_32 (digest
[5]);
13729 digest
[6] = byte_swap_32 (digest
[6]);
13730 digest
[7] = byte_swap_32 (digest
[7]);
13732 return (PARSER_OK
);
13735 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13737 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13739 u32
*digest
= (u32
*) hash_buf
->digest
;
13741 salt_t
*salt
= hash_buf
->salt
;
13743 char *salt_pos
= input_buf
+ 3;
13745 uint iterations_len
= 0;
13747 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13751 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13753 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13754 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13758 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13762 iterations_len
+= 8;
13766 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13769 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13771 char *hash_pos
= strchr (salt_pos
, '$');
13773 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13775 uint salt_len
= hash_pos
- salt_pos
;
13777 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13779 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13781 salt
->salt_len
= salt_len
;
13785 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13787 return (PARSER_OK
);
13790 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13792 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13794 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13796 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13798 u64
*digest
= (u64
*) hash_buf
->digest
;
13800 salt_t
*salt
= hash_buf
->salt
;
13802 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13804 char *iter_pos
= input_buf
+ 4;
13806 char *salt_pos
= strchr (iter_pos
, '$');
13808 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13812 char *hash_pos
= strchr (salt_pos
, '$');
13814 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13816 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13820 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13821 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13822 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13823 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13824 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13825 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13826 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13827 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13829 uint salt_len
= hash_pos
- salt_pos
- 1;
13831 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13833 salt
->salt_len
= salt_len
/ 2;
13835 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13836 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13837 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13838 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13839 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13840 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13841 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13842 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13844 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13845 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13846 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13847 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13848 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13849 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13850 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13851 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13852 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13853 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13855 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13857 salt
->salt_iter
= atoi (iter_pos
) - 1;
13859 return (PARSER_OK
);
13862 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13864 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13866 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13868 u32
*digest
= (u32
*) hash_buf
->digest
;
13870 salt_t
*salt
= hash_buf
->salt
;
13872 char *salt_pos
= input_buf
+ 14;
13874 char *hash_pos
= strchr (salt_pos
, '*');
13876 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13880 uint salt_len
= hash_pos
- salt_pos
- 1;
13882 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13884 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13886 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13888 salt
->salt_len
= salt_len
;
13890 u8 tmp_buf
[100] = { 0 };
13892 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13894 memcpy (digest
, tmp_buf
, 32);
13896 digest
[0] = byte_swap_32 (digest
[0]);
13897 digest
[1] = byte_swap_32 (digest
[1]);
13898 digest
[2] = byte_swap_32 (digest
[2]);
13899 digest
[3] = byte_swap_32 (digest
[3]);
13900 digest
[4] = byte_swap_32 (digest
[4]);
13901 digest
[5] = byte_swap_32 (digest
[5]);
13902 digest
[6] = byte_swap_32 (digest
[6]);
13903 digest
[7] = byte_swap_32 (digest
[7]);
13905 digest
[0] -= SHA256M_A
;
13906 digest
[1] -= SHA256M_B
;
13907 digest
[2] -= SHA256M_C
;
13908 digest
[3] -= SHA256M_D
;
13909 digest
[4] -= SHA256M_E
;
13910 digest
[5] -= SHA256M_F
;
13911 digest
[6] -= SHA256M_G
;
13912 digest
[7] -= SHA256M_H
;
13914 return (PARSER_OK
);
13917 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13919 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13921 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13923 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13925 u64
*digest
= (u64
*) hash_buf
->digest
;
13927 salt_t
*salt
= hash_buf
->salt
;
13929 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13931 char *iter_pos
= input_buf
+ 19;
13933 char *salt_pos
= strchr (iter_pos
, '.');
13935 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13939 char *hash_pos
= strchr (salt_pos
, '.');
13941 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13943 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13947 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13948 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13949 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13950 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13951 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13952 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13953 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13954 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13956 uint salt_len
= hash_pos
- salt_pos
- 1;
13960 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13964 for (i
= 0; i
< salt_len
; i
++)
13966 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13969 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13970 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13972 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13974 salt
->salt_len
= salt_len
;
13976 salt
->salt_iter
= atoi (iter_pos
) - 1;
13978 return (PARSER_OK
);
13981 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13983 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13985 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13987 u64
*digest
= (u64
*) hash_buf
->digest
;
13989 salt_t
*salt
= hash_buf
->salt
;
13991 u8 tmp_buf
[120] = { 0 };
13993 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13995 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13997 memcpy (digest
, tmp_buf
, 64);
13999 digest
[0] = byte_swap_64 (digest
[0]);
14000 digest
[1] = byte_swap_64 (digest
[1]);
14001 digest
[2] = byte_swap_64 (digest
[2]);
14002 digest
[3] = byte_swap_64 (digest
[3]);
14003 digest
[4] = byte_swap_64 (digest
[4]);
14004 digest
[5] = byte_swap_64 (digest
[5]);
14005 digest
[6] = byte_swap_64 (digest
[6]);
14006 digest
[7] = byte_swap_64 (digest
[7]);
14008 digest
[0] -= SHA512M_A
;
14009 digest
[1] -= SHA512M_B
;
14010 digest
[2] -= SHA512M_C
;
14011 digest
[3] -= SHA512M_D
;
14012 digest
[4] -= SHA512M_E
;
14013 digest
[5] -= SHA512M_F
;
14014 digest
[6] -= SHA512M_G
;
14015 digest
[7] -= SHA512M_H
;
14017 int salt_len
= tmp_len
- 64;
14019 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14021 salt
->salt_len
= salt_len
;
14023 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14025 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14027 char *ptr
= (char *) salt
->salt_buf
;
14029 ptr
[salt
->salt_len
] = 0x80;
14032 return (PARSER_OK
);
14035 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14037 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14039 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14043 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14046 u32
*digest
= (u32
*) hash_buf
->digest
;
14048 salt_t
*salt
= hash_buf
->salt
;
14050 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14051 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14052 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14053 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14055 digest
[0] = byte_swap_32 (digest
[0]);
14056 digest
[1] = byte_swap_32 (digest
[1]);
14057 digest
[2] = byte_swap_32 (digest
[2]);
14058 digest
[3] = byte_swap_32 (digest
[3]);
14060 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14062 uint salt_len
= input_len
- 32 - 1;
14064 char *salt_buf
= input_buf
+ 32 + 1;
14066 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14070 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14072 salt
->salt_len
= salt_len
;
14074 return (PARSER_OK
);
14077 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14079 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14081 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14085 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14088 u32
*digest
= (u32
*) hash_buf
->digest
;
14090 salt_t
*salt
= hash_buf
->salt
;
14092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14096 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14098 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14100 uint salt_len
= input_len
- 40 - 1;
14102 char *salt_buf
= input_buf
+ 40 + 1;
14104 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14106 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14108 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14110 salt
->salt_len
= salt_len
;
14112 return (PARSER_OK
);
14115 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14117 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14119 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14123 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14126 u32
*digest
= (u32
*) hash_buf
->digest
;
14128 salt_t
*salt
= hash_buf
->salt
;
14130 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14131 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14132 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14133 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14134 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14135 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14136 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14137 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14139 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14141 uint salt_len
= input_len
- 64 - 1;
14143 char *salt_buf
= input_buf
+ 64 + 1;
14145 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14151 salt
->salt_len
= salt_len
;
14153 return (PARSER_OK
);
14156 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14158 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14160 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14164 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14167 u64
*digest
= (u64
*) hash_buf
->digest
;
14169 salt_t
*salt
= hash_buf
->salt
;
14171 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14172 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14173 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14174 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14175 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14176 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14177 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14178 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14180 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14182 uint salt_len
= input_len
- 128 - 1;
14184 char *salt_buf
= input_buf
+ 128 + 1;
14186 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14188 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14192 salt
->salt_len
= salt_len
;
14194 return (PARSER_OK
);
14197 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14199 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14201 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14203 u32
*digest
= (u32
*) hash_buf
->digest
;
14205 salt_t
*salt
= hash_buf
->salt
;
14207 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14213 char *user_pos
= input_buf
+ 10 + 1;
14215 char *realm_pos
= strchr (user_pos
, '$');
14217 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14219 uint user_len
= realm_pos
- user_pos
;
14221 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14225 char *salt_pos
= strchr (realm_pos
, '$');
14227 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14229 uint realm_len
= salt_pos
- realm_pos
;
14231 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14235 char *data_pos
= strchr (salt_pos
, '$');
14237 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14239 uint salt_len
= data_pos
- salt_pos
;
14241 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14245 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14247 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14253 memcpy (krb5pa
->user
, user_pos
, user_len
);
14254 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14255 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14257 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14259 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14261 const char p0
= data_pos
[i
+ 0];
14262 const char p1
= data_pos
[i
+ 1];
14264 *timestamp_ptr
++ = hex_convert (p1
) << 0
14265 | hex_convert (p0
) << 4;
14268 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14270 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14272 const char p0
= data_pos
[i
+ 0];
14273 const char p1
= data_pos
[i
+ 1];
14275 *checksum_ptr
++ = hex_convert (p1
) << 0
14276 | hex_convert (p0
) << 4;
14280 * copy some data to generic buffers to make sorting happy
14283 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14284 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14285 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14286 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14287 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14288 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14289 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14290 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14291 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14293 salt
->salt_len
= 36;
14295 digest
[0] = krb5pa
->checksum
[0];
14296 digest
[1] = krb5pa
->checksum
[1];
14297 digest
[2] = krb5pa
->checksum
[2];
14298 digest
[3] = krb5pa
->checksum
[3];
14300 return (PARSER_OK
);
14303 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14305 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14307 u32
*digest
= (u32
*) hash_buf
->digest
;
14309 salt_t
*salt
= hash_buf
->salt
;
14315 char *salt_pos
= input_buf
;
14317 char *hash_pos
= strchr (salt_pos
, '$');
14319 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14321 uint salt_len
= hash_pos
- salt_pos
;
14323 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14327 uint hash_len
= input_len
- 1 - salt_len
;
14329 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14337 for (uint i
= 0; i
< salt_len
; i
++)
14339 if (salt_pos
[i
] == ' ') continue;
14344 // SAP user names cannot be longer than 12 characters
14345 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14347 // SAP user name cannot start with ! or ?
14348 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14354 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14356 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14358 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14360 salt
->salt_len
= salt_len
;
14362 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14363 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14367 digest
[0] = byte_swap_32 (digest
[0]);
14368 digest
[1] = byte_swap_32 (digest
[1]);
14370 return (PARSER_OK
);
14373 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14375 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14377 u32
*digest
= (u32
*) hash_buf
->digest
;
14379 salt_t
*salt
= hash_buf
->salt
;
14385 char *salt_pos
= input_buf
;
14387 char *hash_pos
= strchr (salt_pos
, '$');
14389 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14391 uint salt_len
= hash_pos
- salt_pos
;
14393 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14397 uint hash_len
= input_len
- 1 - salt_len
;
14399 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14407 for (uint i
= 0; i
< salt_len
; i
++)
14409 if (salt_pos
[i
] == ' ') continue;
14414 // SAP user names cannot be longer than 12 characters
14415 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14416 // so far nobody complained so we stay with this because it helps in optimization
14417 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14419 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14421 // SAP user name cannot start with ! or ?
14422 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14428 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14430 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14432 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14434 salt
->salt_len
= salt_len
;
14436 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14437 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14438 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14439 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14440 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14442 return (PARSER_OK
);
14445 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14447 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14449 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14451 u64
*digest
= (u64
*) hash_buf
->digest
;
14453 salt_t
*salt
= hash_buf
->salt
;
14455 char *iter_pos
= input_buf
+ 3;
14457 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14459 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14461 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14463 salt
->salt_iter
= salt_iter
;
14465 char *salt_pos
= iter_pos
+ 1;
14469 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14471 salt
->salt_len
= salt_len
;
14473 char *hash_pos
= salt_pos
+ salt_len
;
14475 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14479 char *tmp
= (char *) salt
->salt_buf_pc
;
14481 tmp
[0] = hash_pos
[42];
14485 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14486 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14487 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14488 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14494 return (PARSER_OK
);
14497 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14499 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14501 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14503 u32
*digest
= (u32
*) hash_buf
->digest
;
14505 salt_t
*salt
= hash_buf
->salt
;
14507 char *salt_buf
= input_buf
+ 6;
14509 uint salt_len
= 16;
14511 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14513 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14515 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14517 salt
->salt_len
= salt_len
;
14519 char *hash_pos
= input_buf
+ 6 + 16;
14521 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14522 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14523 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14524 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14525 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14526 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14527 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14528 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14530 return (PARSER_OK
);
14533 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14535 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14537 u32
*digest
= (u32
*) hash_buf
->digest
;
14539 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14540 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14544 return (PARSER_OK
);
14547 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14549 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14551 u32
*digest
= (u32
*) hash_buf
->digest
;
14553 salt_t
*salt
= hash_buf
->salt
;
14555 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14557 char *saltbuf_pos
= input_buf
;
14559 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14561 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14563 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14565 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14566 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14568 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14572 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14574 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14576 char *salt_ptr
= (char *) saltbuf_pos
;
14577 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14582 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14584 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14587 rakp_ptr
[j
] = 0x80;
14589 rakp
->salt_len
= j
;
14591 for (i
= 0; i
< 64; i
++)
14593 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14596 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14597 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14598 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14599 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14600 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14601 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14602 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14603 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14605 salt
->salt_len
= 32; // muss min. 32 haben
14607 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14608 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14609 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14610 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14611 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14613 return (PARSER_OK
);
14616 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14618 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14620 u32
*digest
= (u32
*) hash_buf
->digest
;
14622 salt_t
*salt
= hash_buf
->salt
;
14624 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14626 char *salt_pos
= input_buf
+ 1;
14628 memcpy (salt
->salt_buf
, salt_pos
, 8);
14630 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14631 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14633 salt
->salt_len
= 8;
14635 char *hash_pos
= salt_pos
+ 8;
14637 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14638 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14639 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14640 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14641 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14643 digest
[0] -= SHA1M_A
;
14644 digest
[1] -= SHA1M_B
;
14645 digest
[2] -= SHA1M_C
;
14646 digest
[3] -= SHA1M_D
;
14647 digest
[4] -= SHA1M_E
;
14649 return (PARSER_OK
);
14652 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14654 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14656 u32
*digest
= (u32
*) hash_buf
->digest
;
14658 salt_t
*salt
= hash_buf
->salt
;
14660 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14661 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14662 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14663 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14665 digest
[0] = byte_swap_32 (digest
[0]);
14666 digest
[1] = byte_swap_32 (digest
[1]);
14667 digest
[2] = byte_swap_32 (digest
[2]);
14668 digest
[3] = byte_swap_32 (digest
[3]);
14670 digest
[0] -= MD5M_A
;
14671 digest
[1] -= MD5M_B
;
14672 digest
[2] -= MD5M_C
;
14673 digest
[3] -= MD5M_D
;
14675 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14677 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14679 u32
*salt_buf
= salt
->salt_buf
;
14681 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14682 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14683 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14684 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14686 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14687 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14688 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14689 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14691 salt
->salt_len
= 16 + 1;
14693 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14695 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14697 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14699 return (PARSER_OK
);
14702 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14704 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14706 u32
*digest
= (u32
*) hash_buf
->digest
;
14708 salt_t
*salt
= hash_buf
->salt
;
14710 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14716 char *hashbuf_pos
= input_buf
;
14718 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14720 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14722 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14724 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14728 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14730 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14732 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14734 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14738 char *databuf_pos
= strchr (iteration_pos
, ':');
14740 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14742 const uint iteration_len
= databuf_pos
- iteration_pos
;
14744 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14745 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14747 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14749 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14750 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14756 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14757 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14758 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14759 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14760 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14761 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14762 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14763 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14767 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14769 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14771 const char p0
= saltbuf_pos
[i
+ 0];
14772 const char p1
= saltbuf_pos
[i
+ 1];
14774 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14775 | hex_convert (p0
) << 4;
14778 salt
->salt_buf
[4] = 0x01000000;
14779 salt
->salt_buf
[5] = 0x80;
14781 salt
->salt_len
= saltbuf_len
/ 2;
14785 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14789 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14791 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14793 const char p0
= databuf_pos
[i
+ 0];
14794 const char p1
= databuf_pos
[i
+ 1];
14796 *databuf_ptr
++ = hex_convert (p1
) << 0
14797 | hex_convert (p0
) << 4;
14800 *databuf_ptr
++ = 0x80;
14802 for (uint i
= 0; i
< 512; i
++)
14804 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14807 cloudkey
->data_len
= databuf_len
/ 2;
14809 return (PARSER_OK
);
14812 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14814 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14816 u32
*digest
= (u32
*) hash_buf
->digest
;
14818 salt_t
*salt
= hash_buf
->salt
;
14824 char *hashbuf_pos
= input_buf
;
14826 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14828 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14830 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14832 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14836 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14838 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14840 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14842 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14844 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14848 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14850 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14852 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14854 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14856 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14860 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14862 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14863 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14865 // ok, the plan for this algorithm is the following:
14866 // we have 2 salts here, the domain-name and a random salt
14867 // while both are used in the initial transformation,
14868 // only the random salt is used in the following iterations
14869 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14870 // and one that includes only the real salt (stored into salt_buf[]).
14871 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14873 u8 tmp_buf
[100] = { 0 };
14875 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14877 memcpy (digest
, tmp_buf
, 20);
14879 digest
[0] = byte_swap_32 (digest
[0]);
14880 digest
[1] = byte_swap_32 (digest
[1]);
14881 digest
[2] = byte_swap_32 (digest
[2]);
14882 digest
[3] = byte_swap_32 (digest
[3]);
14883 digest
[4] = byte_swap_32 (digest
[4]);
14887 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14889 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14891 char *len_ptr
= NULL
;
14893 for (uint i
= 0; i
< domainbuf_len
; i
++)
14895 if (salt_buf_pc_ptr
[i
] == '.')
14897 len_ptr
= &salt_buf_pc_ptr
[i
];
14907 salt
->salt_buf_pc
[7] = domainbuf_len
;
14911 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14913 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14915 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14917 salt
->salt_len
= salt_len
;
14921 salt
->salt_iter
= atoi (iteration_pos
);
14923 return (PARSER_OK
);
14926 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14928 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14930 u32
*digest
= (u32
*) hash_buf
->digest
;
14932 salt_t
*salt
= hash_buf
->salt
;
14934 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14935 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14936 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14937 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14938 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14940 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14942 uint salt_len
= input_len
- 40 - 1;
14944 char *salt_buf
= input_buf
+ 40 + 1;
14946 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14948 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14950 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14952 salt
->salt_len
= salt_len
;
14954 return (PARSER_OK
);
14957 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14959 const u8 ascii_to_ebcdic
[] =
14961 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14962 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14963 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14964 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14965 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14966 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14967 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14968 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14969 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14970 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14971 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14972 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14973 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14974 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14975 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14976 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14979 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14981 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14983 u32
*digest
= (u32
*) hash_buf
->digest
;
14985 salt_t
*salt
= hash_buf
->salt
;
14987 char *salt_pos
= input_buf
+ 6 + 1;
14989 char *digest_pos
= strchr (salt_pos
, '*');
14991 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14993 uint salt_len
= digest_pos
- salt_pos
;
14995 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14997 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14999 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
15003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15004 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15006 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15008 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15010 salt
->salt_len
= salt_len
;
15012 for (uint i
= 0; i
< salt_len
; i
++)
15014 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15016 for (uint i
= salt_len
; i
< 8; i
++)
15018 salt_buf_pc_ptr
[i
] = 0x40;
15023 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15025 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15026 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15028 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15029 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15031 digest
[0] = byte_swap_32 (digest
[0]);
15032 digest
[1] = byte_swap_32 (digest
[1]);
15034 IP (digest
[0], digest
[1], tt
);
15036 digest
[0] = rotr32 (digest
[0], 29);
15037 digest
[1] = rotr32 (digest
[1], 29);
15041 return (PARSER_OK
);
15044 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15046 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15048 u32
*digest
= (u32
*) hash_buf
->digest
;
15050 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15051 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15052 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15053 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15055 digest
[0] = byte_swap_32 (digest
[0]);
15056 digest
[1] = byte_swap_32 (digest
[1]);
15057 digest
[2] = byte_swap_32 (digest
[2]);
15058 digest
[3] = byte_swap_32 (digest
[3]);
15060 return (PARSER_OK
);
15063 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15065 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15067 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15069 u32
*digest
= (u32
*) hash_buf
->digest
;
15071 salt_t
*salt
= hash_buf
->salt
;
15073 u8 tmp_buf
[120] = { 0 };
15075 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15077 tmp_buf
[3] += -4; // dont ask!
15079 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15081 salt
->salt_len
= 5;
15083 memcpy (digest
, tmp_buf
+ 5, 9);
15085 // yes, only 9 byte are needed to crack, but 10 to display
15087 salt
->salt_buf_pc
[7] = input_buf
[20];
15089 return (PARSER_OK
);
15092 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15094 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15096 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15098 u32
*digest
= (u32
*) hash_buf
->digest
;
15100 salt_t
*salt
= hash_buf
->salt
;
15102 u8 tmp_buf
[120] = { 0 };
15104 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15106 tmp_buf
[3] += -4; // dont ask!
15110 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15112 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)
15116 char tmp_iter_buf
[11] = { 0 };
15118 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15120 tmp_iter_buf
[10] = 0;
15122 salt
->salt_iter
= atoi (tmp_iter_buf
);
15124 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15126 return (PARSER_SALT_ITERATION
);
15129 salt
->salt_iter
--; // first round in init
15131 // 2 additional bytes for display only
15133 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15134 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15138 memcpy (digest
, tmp_buf
+ 28, 8);
15140 digest
[0] = byte_swap_32 (digest
[0]);
15141 digest
[1] = byte_swap_32 (digest
[1]);
15145 return (PARSER_OK
);
15148 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15150 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15152 u32
*digest
= (u32
*) hash_buf
->digest
;
15154 salt_t
*salt
= hash_buf
->salt
;
15156 char *salt_buf_pos
= input_buf
;
15158 char *hash_buf_pos
= salt_buf_pos
+ 6;
15160 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15161 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15162 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15163 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15164 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15165 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15166 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15167 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15169 digest
[0] -= SHA256M_A
;
15170 digest
[1] -= SHA256M_B
;
15171 digest
[2] -= SHA256M_C
;
15172 digest
[3] -= SHA256M_D
;
15173 digest
[4] -= SHA256M_E
;
15174 digest
[5] -= SHA256M_F
;
15175 digest
[6] -= SHA256M_G
;
15176 digest
[7] -= SHA256M_H
;
15178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15180 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15184 salt
->salt_len
= salt_len
;
15186 return (PARSER_OK
);
15189 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15191 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15193 u32
*digest
= (u32
*) hash_buf
->digest
;
15195 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15197 salt_t
*salt
= hash_buf
->salt
;
15199 char *salt_buf
= input_buf
+ 6;
15201 char *digest_buf
= strchr (salt_buf
, '$');
15203 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15205 uint salt_len
= digest_buf
- salt_buf
;
15207 digest_buf
++; // skip the '$' symbol
15209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15215 salt
->salt_len
= salt_len
;
15217 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15218 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15219 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15220 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15222 digest
[0] = byte_swap_32 (digest
[0]);
15223 digest
[1] = byte_swap_32 (digest
[1]);
15224 digest
[2] = byte_swap_32 (digest
[2]);
15225 digest
[3] = byte_swap_32 (digest
[3]);
15227 digest
[0] -= MD5M_A
;
15228 digest
[1] -= MD5M_B
;
15229 digest
[2] -= MD5M_C
;
15230 digest
[3] -= MD5M_D
;
15232 return (PARSER_OK
);
15235 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15237 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15239 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15241 u32
*digest
= (u32
*) hash_buf
->digest
;
15243 salt_t
*salt
= hash_buf
->salt
;
15245 char *salt_buf
= input_buf
+ 3;
15247 char *digest_buf
= strchr (salt_buf
, '$');
15249 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15251 uint salt_len
= digest_buf
- salt_buf
;
15253 digest_buf
++; // skip the '$' symbol
15255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15257 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15261 salt_buf_ptr
[salt_len
] = 0x2d;
15263 salt
->salt_len
= salt_len
+ 1;
15265 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15266 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15267 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15268 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15270 digest
[0] = byte_swap_32 (digest
[0]);
15271 digest
[1] = byte_swap_32 (digest
[1]);
15272 digest
[2] = byte_swap_32 (digest
[2]);
15273 digest
[3] = byte_swap_32 (digest
[3]);
15275 digest
[0] -= MD5M_A
;
15276 digest
[1] -= MD5M_B
;
15277 digest
[2] -= MD5M_C
;
15278 digest
[3] -= MD5M_D
;
15280 return (PARSER_OK
);
15283 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15285 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15287 u32
*digest
= (u32
*) hash_buf
->digest
;
15289 salt_t
*salt
= hash_buf
->salt
;
15291 u8 tmp_buf
[100] = { 0 };
15293 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15295 memcpy (digest
, tmp_buf
, 20);
15297 digest
[0] = byte_swap_32 (digest
[0]);
15298 digest
[1] = byte_swap_32 (digest
[1]);
15299 digest
[2] = byte_swap_32 (digest
[2]);
15300 digest
[3] = byte_swap_32 (digest
[3]);
15301 digest
[4] = byte_swap_32 (digest
[4]);
15303 digest
[0] -= SHA1M_A
;
15304 digest
[1] -= SHA1M_B
;
15305 digest
[2] -= SHA1M_C
;
15306 digest
[3] -= SHA1M_D
;
15307 digest
[4] -= SHA1M_E
;
15309 salt
->salt_buf
[0] = 0x80;
15311 salt
->salt_len
= 0;
15313 return (PARSER_OK
);
15316 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15318 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15320 u32
*digest
= (u32
*) hash_buf
->digest
;
15322 salt_t
*salt
= hash_buf
->salt
;
15324 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15325 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15326 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15327 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15329 digest
[0] = byte_swap_32 (digest
[0]);
15330 digest
[1] = byte_swap_32 (digest
[1]);
15331 digest
[2] = byte_swap_32 (digest
[2]);
15332 digest
[3] = byte_swap_32 (digest
[3]);
15334 digest
[0] -= MD5M_A
;
15335 digest
[1] -= MD5M_B
;
15336 digest
[2] -= MD5M_C
;
15337 digest
[3] -= MD5M_D
;
15339 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15341 uint salt_len
= input_len
- 32 - 1;
15343 char *salt_buf
= input_buf
+ 32 + 1;
15345 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15347 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15349 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15352 * add static "salt" part
15355 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15359 salt
->salt_len
= salt_len
;
15361 return (PARSER_OK
);
15364 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15366 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15368 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15370 u32
*digest
= (u32
*) hash_buf
->digest
;
15372 salt_t
*salt
= hash_buf
->salt
;
15374 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15380 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15382 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15384 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15386 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15388 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15392 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15394 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15396 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15398 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15402 char *keybuf_pos
= strchr (keylen_pos
, '$');
15404 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15406 uint keylen_len
= keybuf_pos
- keylen_pos
;
15408 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15412 char *databuf_pos
= strchr (keybuf_pos
, '$');
15414 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15416 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15418 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15422 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15424 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15430 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15431 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15432 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15433 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15435 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15436 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15437 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15438 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15440 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15441 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15442 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15443 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15445 salt
->salt_len
= 16;
15446 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15448 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15450 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15453 return (PARSER_OK
);
15456 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15458 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15460 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15462 u32
*digest
= (u32
*) hash_buf
->digest
;
15464 salt_t
*salt
= hash_buf
->salt
;
15470 // first is the N salt parameter
15472 char *N_pos
= input_buf
+ 6;
15474 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15478 salt
->scrypt_N
= atoi (N_pos
);
15482 char *r_pos
= strchr (N_pos
, ':');
15484 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15488 salt
->scrypt_r
= atoi (r_pos
);
15492 char *p_pos
= strchr (r_pos
, ':');
15494 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15498 salt
->scrypt_p
= atoi (p_pos
);
15502 char *saltbuf_pos
= strchr (p_pos
, ':');
15504 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15508 char *hash_pos
= strchr (saltbuf_pos
, ':');
15510 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15516 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15518 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15520 u8 tmp_buf
[33] = { 0 };
15522 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15524 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15526 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15528 salt
->salt_len
= tmp_len
;
15529 salt
->salt_iter
= 1;
15531 // digest - base64 decode
15533 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15535 tmp_len
= input_len
- (hash_pos
- input_buf
);
15537 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15539 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15541 memcpy (digest
, tmp_buf
, 32);
15543 return (PARSER_OK
);
15546 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15548 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15550 u32
*digest
= (u32
*) hash_buf
->digest
;
15552 salt_t
*salt
= hash_buf
->salt
;
15558 char decrypted
[76] = { 0 }; // iv + hash
15560 juniper_decrypt_hash (input_buf
, decrypted
);
15562 char *md5crypt_hash
= decrypted
+ 12;
15564 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15566 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15568 char *salt_pos
= md5crypt_hash
+ 3;
15570 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15572 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15574 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15578 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15580 return (PARSER_OK
);
15583 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15585 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15587 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15589 u32
*digest
= (u32
*) hash_buf
->digest
;
15591 salt_t
*salt
= hash_buf
->salt
;
15593 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15599 // first is *raw* salt
15601 char *salt_pos
= input_buf
+ 3;
15603 char *hash_pos
= strchr (salt_pos
, '$');
15605 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15607 uint salt_len
= hash_pos
- salt_pos
;
15609 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15613 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15615 memcpy (salt_buf_ptr
, salt_pos
, 14);
15617 salt_buf_ptr
[17] = 0x01;
15618 salt_buf_ptr
[18] = 0x80;
15620 // add some stuff to normal salt to make sorted happy
15622 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15623 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15624 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15625 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15627 salt
->salt_len
= salt_len
;
15628 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
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);
15642 digest
[0] = byte_swap_32 (digest
[0]);
15643 digest
[1] = byte_swap_32 (digest
[1]);
15644 digest
[2] = byte_swap_32 (digest
[2]);
15645 digest
[3] = byte_swap_32 (digest
[3]);
15646 digest
[4] = byte_swap_32 (digest
[4]);
15647 digest
[5] = byte_swap_32 (digest
[5]);
15648 digest
[6] = byte_swap_32 (digest
[6]);
15649 digest
[7] = byte_swap_32 (digest
[7]);
15651 return (PARSER_OK
);
15654 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15656 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15658 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15660 u32
*digest
= (u32
*) hash_buf
->digest
;
15662 salt_t
*salt
= hash_buf
->salt
;
15668 // first is *raw* salt
15670 char *salt_pos
= input_buf
+ 3;
15672 char *hash_pos
= strchr (salt_pos
, '$');
15674 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15676 uint salt_len
= hash_pos
- salt_pos
;
15678 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15680 salt
->salt_len
= salt_len
;
15683 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15685 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15686 salt_buf_ptr
[salt_len
] = 0;
15688 // base64 decode hash
15690 u8 tmp_buf
[100] = { 0 };
15692 uint hash_len
= input_len
- 3 - salt_len
- 1;
15694 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15696 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15698 memcpy (digest
, tmp_buf
, 32);
15701 salt
->scrypt_N
= 16384;
15702 salt
->scrypt_r
= 1;
15703 salt
->scrypt_p
= 1;
15704 salt
->salt_iter
= 1;
15706 return (PARSER_OK
);
15709 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15711 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15713 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15715 u32
*digest
= (u32
*) hash_buf
->digest
;
15717 salt_t
*salt
= hash_buf
->salt
;
15719 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15725 char *version_pos
= input_buf
+ 8 + 1;
15727 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15729 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15731 u32 version_len
= verifierHashSize_pos
- version_pos
;
15733 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15735 verifierHashSize_pos
++;
15737 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15739 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15741 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15743 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15747 char *saltSize_pos
= strchr (keySize_pos
, '*');
15749 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15751 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15753 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15757 char *osalt_pos
= strchr (saltSize_pos
, '*');
15759 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15761 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15763 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15767 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15769 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15773 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15775 encryptedVerifier_pos
++;
15777 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15779 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15781 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15783 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15785 encryptedVerifierHash_pos
++;
15787 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;
15789 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15791 const uint version
= atoi (version_pos
);
15793 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15795 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15797 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15799 const uint keySize
= atoi (keySize_pos
);
15801 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15803 office2007
->keySize
= keySize
;
15805 const uint saltSize
= atoi (saltSize_pos
);
15807 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15813 salt
->salt_len
= 16;
15814 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15816 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15817 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15818 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15819 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15825 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15826 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15827 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15828 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15830 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15831 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15832 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15833 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15834 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15840 digest
[0] = office2007
->encryptedVerifierHash
[0];
15841 digest
[1] = office2007
->encryptedVerifierHash
[1];
15842 digest
[2] = office2007
->encryptedVerifierHash
[2];
15843 digest
[3] = office2007
->encryptedVerifierHash
[3];
15845 return (PARSER_OK
);
15848 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15850 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15852 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15854 u32
*digest
= (u32
*) hash_buf
->digest
;
15856 salt_t
*salt
= hash_buf
->salt
;
15858 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15864 char *version_pos
= input_buf
+ 8 + 1;
15866 char *spinCount_pos
= strchr (version_pos
, '*');
15868 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15870 u32 version_len
= spinCount_pos
- version_pos
;
15872 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15876 char *keySize_pos
= strchr (spinCount_pos
, '*');
15878 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15880 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15882 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15886 char *saltSize_pos
= strchr (keySize_pos
, '*');
15888 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15890 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15892 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15896 char *osalt_pos
= strchr (saltSize_pos
, '*');
15898 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15900 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15902 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15906 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15908 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15910 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15912 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15914 encryptedVerifier_pos
++;
15916 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15918 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15920 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15922 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15924 encryptedVerifierHash_pos
++;
15926 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;
15928 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15930 const uint version
= atoi (version_pos
);
15932 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15934 const uint spinCount
= atoi (spinCount_pos
);
15936 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15938 const uint keySize
= atoi (keySize_pos
);
15940 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15942 const uint saltSize
= atoi (saltSize_pos
);
15944 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15950 salt
->salt_len
= 16;
15951 salt
->salt_iter
= spinCount
;
15953 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15954 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15955 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15956 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15962 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15963 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15964 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15965 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15967 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15968 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15969 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15970 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15971 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15972 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15973 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15974 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15980 digest
[0] = office2010
->encryptedVerifierHash
[0];
15981 digest
[1] = office2010
->encryptedVerifierHash
[1];
15982 digest
[2] = office2010
->encryptedVerifierHash
[2];
15983 digest
[3] = office2010
->encryptedVerifierHash
[3];
15985 return (PARSER_OK
);
15988 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15990 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15992 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15994 u32
*digest
= (u32
*) hash_buf
->digest
;
15996 salt_t
*salt
= hash_buf
->salt
;
15998 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16004 char *version_pos
= input_buf
+ 8 + 1;
16006 char *spinCount_pos
= strchr (version_pos
, '*');
16008 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16010 u32 version_len
= spinCount_pos
- version_pos
;
16012 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16016 char *keySize_pos
= strchr (spinCount_pos
, '*');
16018 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16020 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16022 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16026 char *saltSize_pos
= strchr (keySize_pos
, '*');
16028 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16030 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16032 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16036 char *osalt_pos
= strchr (saltSize_pos
, '*');
16038 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16040 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16042 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16046 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16048 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16050 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16052 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16054 encryptedVerifier_pos
++;
16056 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16058 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16060 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16062 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16064 encryptedVerifierHash_pos
++;
16066 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;
16068 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16070 const uint version
= atoi (version_pos
);
16072 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16074 const uint spinCount
= atoi (spinCount_pos
);
16076 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16078 const uint keySize
= atoi (keySize_pos
);
16080 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16082 const uint saltSize
= atoi (saltSize_pos
);
16084 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16090 salt
->salt_len
= 16;
16091 salt
->salt_iter
= spinCount
;
16093 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16094 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16095 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16096 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16102 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16103 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16104 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16105 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16107 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16108 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16109 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16110 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16111 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16112 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16113 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16114 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16120 digest
[0] = office2013
->encryptedVerifierHash
[0];
16121 digest
[1] = office2013
->encryptedVerifierHash
[1];
16122 digest
[2] = office2013
->encryptedVerifierHash
[2];
16123 digest
[3] = office2013
->encryptedVerifierHash
[3];
16125 return (PARSER_OK
);
16128 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16130 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16132 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16134 u32
*digest
= (u32
*) hash_buf
->digest
;
16136 salt_t
*salt
= hash_buf
->salt
;
16138 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16144 char *version_pos
= input_buf
+ 11;
16146 char *osalt_pos
= strchr (version_pos
, '*');
16148 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16150 u32 version_len
= osalt_pos
- version_pos
;
16152 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16156 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16158 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16160 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16162 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16164 encryptedVerifier_pos
++;
16166 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16168 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16172 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16174 encryptedVerifierHash_pos
++;
16176 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16178 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16180 const uint version
= *version_pos
- 0x30;
16182 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16188 oldoffice01
->version
= version
;
16190 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16191 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16192 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16193 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16195 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16196 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16197 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16198 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16200 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16201 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16202 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16203 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16205 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16206 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16207 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16208 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16214 salt
->salt_len
= 16;
16216 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16217 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16218 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16219 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16221 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16222 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16223 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16224 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16226 // this is a workaround as office produces multiple documents with the same salt
16228 salt
->salt_len
+= 32;
16230 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16231 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16232 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16233 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16234 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16235 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16236 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16237 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16243 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16244 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16245 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16246 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16248 return (PARSER_OK
);
16251 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16253 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16256 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16258 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16260 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16262 u32
*digest
= (u32
*) hash_buf
->digest
;
16264 salt_t
*salt
= hash_buf
->salt
;
16266 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16272 char *version_pos
= input_buf
+ 11;
16274 char *osalt_pos
= strchr (version_pos
, '*');
16276 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16278 u32 version_len
= osalt_pos
- version_pos
;
16280 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16284 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16286 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16288 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16290 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16292 encryptedVerifier_pos
++;
16294 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16296 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16298 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16300 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16302 encryptedVerifierHash_pos
++;
16304 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16306 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16308 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16310 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16314 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16316 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16318 const uint version
= *version_pos
- 0x30;
16320 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16326 oldoffice01
->version
= version
;
16328 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16329 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16330 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16331 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16333 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16334 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16335 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16336 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16338 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16339 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16340 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16341 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16343 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16344 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16345 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16346 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16348 oldoffice01
->rc4key
[1] = 0;
16349 oldoffice01
->rc4key
[0] = 0;
16351 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16352 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16353 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16354 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16355 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16356 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16357 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16358 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16359 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16360 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16362 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16363 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16369 salt
->salt_len
= 16;
16371 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16372 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16373 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16374 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16376 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16377 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16378 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16379 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16381 // this is a workaround as office produces multiple documents with the same salt
16383 salt
->salt_len
+= 32;
16385 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16386 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16387 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16388 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16389 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16390 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16391 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16392 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16398 digest
[0] = oldoffice01
->rc4key
[0];
16399 digest
[1] = oldoffice01
->rc4key
[1];
16403 return (PARSER_OK
);
16406 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16408 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16410 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16412 u32
*digest
= (u32
*) hash_buf
->digest
;
16414 salt_t
*salt
= hash_buf
->salt
;
16416 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16422 char *version_pos
= input_buf
+ 11;
16424 char *osalt_pos
= strchr (version_pos
, '*');
16426 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16428 u32 version_len
= osalt_pos
- version_pos
;
16430 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16434 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16436 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16438 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16440 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16442 encryptedVerifier_pos
++;
16444 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16446 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16448 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16450 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16452 encryptedVerifierHash_pos
++;
16454 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16456 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16458 const uint version
= *version_pos
- 0x30;
16460 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16466 oldoffice34
->version
= version
;
16468 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16469 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16470 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16471 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16473 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16474 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16475 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16476 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16478 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16479 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16480 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16481 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16482 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16484 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16485 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16486 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16487 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16488 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16494 salt
->salt_len
= 16;
16496 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16497 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16498 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16499 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16501 // this is a workaround as office produces multiple documents with the same salt
16503 salt
->salt_len
+= 32;
16505 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16506 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16507 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16508 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16509 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16510 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16511 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16512 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16518 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16519 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16520 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16521 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16523 return (PARSER_OK
);
16526 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16528 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16530 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16533 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16535 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16537 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16539 u32
*digest
= (u32
*) hash_buf
->digest
;
16541 salt_t
*salt
= hash_buf
->salt
;
16543 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16549 char *version_pos
= input_buf
+ 11;
16551 char *osalt_pos
= strchr (version_pos
, '*');
16553 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16555 u32 version_len
= osalt_pos
- version_pos
;
16557 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16561 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16563 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16565 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16567 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16569 encryptedVerifier_pos
++;
16571 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16573 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16575 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16577 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16579 encryptedVerifierHash_pos
++;
16581 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16583 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16585 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16587 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16591 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16593 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16595 const uint version
= *version_pos
- 0x30;
16597 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16603 oldoffice34
->version
= version
;
16605 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16606 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16607 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16608 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16610 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16611 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16612 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16613 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16615 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16616 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16617 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16618 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16619 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16621 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16622 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16623 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16624 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16625 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16627 oldoffice34
->rc4key
[1] = 0;
16628 oldoffice34
->rc4key
[0] = 0;
16630 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16631 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16632 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16633 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16634 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16635 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16636 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16637 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16638 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16639 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16641 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16642 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16648 salt
->salt_len
= 16;
16650 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16651 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16652 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16653 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16655 // this is a workaround as office produces multiple documents with the same salt
16657 salt
->salt_len
+= 32;
16659 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16660 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16661 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16662 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16663 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16664 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16665 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16666 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16672 digest
[0] = oldoffice34
->rc4key
[0];
16673 digest
[1] = oldoffice34
->rc4key
[1];
16677 return (PARSER_OK
);
16680 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16682 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16684 u32
*digest
= (u32
*) hash_buf
->digest
;
16686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16691 digest
[0] = byte_swap_32 (digest
[0]);
16692 digest
[1] = byte_swap_32 (digest
[1]);
16693 digest
[2] = byte_swap_32 (digest
[2]);
16694 digest
[3] = byte_swap_32 (digest
[3]);
16696 return (PARSER_OK
);
16699 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16701 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16703 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16705 u32
*digest
= (u32
*) hash_buf
->digest
;
16707 salt_t
*salt
= hash_buf
->salt
;
16709 char *signature_pos
= input_buf
;
16711 char *salt_pos
= strchr (signature_pos
, '$');
16713 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16715 u32 signature_len
= salt_pos
- signature_pos
;
16717 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16721 char *hash_pos
= strchr (salt_pos
, '$');
16723 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16725 u32 salt_len
= hash_pos
- salt_pos
;
16727 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16731 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16733 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16735 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16736 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16737 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16738 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16739 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16741 digest
[0] -= SHA1M_A
;
16742 digest
[1] -= SHA1M_B
;
16743 digest
[2] -= SHA1M_C
;
16744 digest
[3] -= SHA1M_D
;
16745 digest
[4] -= SHA1M_E
;
16747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16749 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16751 salt
->salt_len
= salt_len
;
16753 return (PARSER_OK
);
16756 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16758 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16760 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16762 u32
*digest
= (u32
*) hash_buf
->digest
;
16764 salt_t
*salt
= hash_buf
->salt
;
16766 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16772 char *iter_pos
= input_buf
+ 14;
16774 const int iter
= atoi (iter_pos
);
16776 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16778 salt
->salt_iter
= iter
- 1;
16780 char *salt_pos
= strchr (iter_pos
, '$');
16782 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16786 char *hash_pos
= strchr (salt_pos
, '$');
16788 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16790 const uint salt_len
= hash_pos
- salt_pos
;
16794 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16796 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16798 salt
->salt_len
= salt_len
;
16800 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16801 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16803 // add some stuff to normal salt to make sorted happy
16805 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16806 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16807 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16808 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16809 salt
->salt_buf
[4] = salt
->salt_iter
;
16811 // base64 decode hash
16813 u8 tmp_buf
[100] = { 0 };
16815 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16817 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16819 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16821 memcpy (digest
, tmp_buf
, 32);
16823 digest
[0] = byte_swap_32 (digest
[0]);
16824 digest
[1] = byte_swap_32 (digest
[1]);
16825 digest
[2] = byte_swap_32 (digest
[2]);
16826 digest
[3] = byte_swap_32 (digest
[3]);
16827 digest
[4] = byte_swap_32 (digest
[4]);
16828 digest
[5] = byte_swap_32 (digest
[5]);
16829 digest
[6] = byte_swap_32 (digest
[6]);
16830 digest
[7] = byte_swap_32 (digest
[7]);
16832 return (PARSER_OK
);
16835 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16837 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16839 u32
*digest
= (u32
*) hash_buf
->digest
;
16841 salt_t
*salt
= hash_buf
->salt
;
16843 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16844 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16848 digest
[0] = byte_swap_32 (digest
[0]);
16849 digest
[1] = byte_swap_32 (digest
[1]);
16851 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16852 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16853 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16855 char iter_c
= input_buf
[17];
16856 char iter_d
= input_buf
[19];
16858 // atm only defaults, let's see if there's more request
16859 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16860 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16862 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16864 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16865 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16866 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16867 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16869 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16870 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16871 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16872 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16874 salt
->salt_len
= 16;
16876 return (PARSER_OK
);
16879 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16881 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16883 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16885 u32
*digest
= (u32
*) hash_buf
->digest
;
16887 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16889 salt_t
*salt
= hash_buf
->salt
;
16891 char *salt_pos
= input_buf
+ 10;
16893 char *hash_pos
= strchr (salt_pos
, '$');
16895 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16897 uint salt_len
= hash_pos
- salt_pos
;
16901 uint hash_len
= input_len
- 10 - salt_len
- 1;
16903 // base64 decode salt
16905 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16907 u8 tmp_buf
[100] = { 0 };
16909 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16911 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16913 tmp_buf
[salt_len
] = 0x80;
16915 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16917 salt
->salt_len
= salt_len
;
16919 // base64 decode hash
16921 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16923 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16925 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16927 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16929 uint user_len
= hash_len
- 32;
16931 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16933 user_len
--; // skip the trailing space
16935 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16936 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16937 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16938 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16940 digest
[0] = byte_swap_32 (digest
[0]);
16941 digest
[1] = byte_swap_32 (digest
[1]);
16942 digest
[2] = byte_swap_32 (digest
[2]);
16943 digest
[3] = byte_swap_32 (digest
[3]);
16945 // store username for host only (output hash if cracked)
16947 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16948 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16950 return (PARSER_OK
);
16953 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16955 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16957 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16959 u32
*digest
= (u32
*) hash_buf
->digest
;
16961 salt_t
*salt
= hash_buf
->salt
;
16963 char *iter_pos
= input_buf
+ 10;
16965 u32 iter
= atoi (iter_pos
);
16969 return (PARSER_SALT_ITERATION
);
16972 iter
--; // first iteration is special
16974 salt
->salt_iter
= iter
;
16976 char *base64_pos
= strchr (iter_pos
, '}');
16978 if (base64_pos
== NULL
)
16980 return (PARSER_SIGNATURE_UNMATCHED
);
16985 // base64 decode salt
16987 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16989 u8 tmp_buf
[100] = { 0 };
16991 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16993 if (decoded_len
< 24)
16995 return (PARSER_SALT_LENGTH
);
17000 uint salt_len
= decoded_len
- 20;
17002 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
17003 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17005 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17007 salt
->salt_len
= salt_len
;
17011 u32
*digest_ptr
= (u32
*) tmp_buf
;
17013 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17014 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17015 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17016 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17017 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17019 return (PARSER_OK
);
17022 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17024 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17026 u32
*digest
= (u32
*) hash_buf
->digest
;
17028 salt_t
*salt
= hash_buf
->salt
;
17030 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17031 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17032 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17033 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17034 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17036 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17038 uint salt_len
= input_len
- 40 - 1;
17040 char *salt_buf
= input_buf
+ 40 + 1;
17042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17044 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17046 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17048 salt
->salt_len
= salt_len
;
17050 return (PARSER_OK
);
17053 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17055 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17057 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17059 u32
*digest
= (u32
*) hash_buf
->digest
;
17061 salt_t
*salt
= hash_buf
->salt
;
17063 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17069 char *V_pos
= input_buf
+ 5;
17071 char *R_pos
= strchr (V_pos
, '*');
17073 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17075 u32 V_len
= R_pos
- V_pos
;
17079 char *bits_pos
= strchr (R_pos
, '*');
17081 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17083 u32 R_len
= bits_pos
- R_pos
;
17087 char *P_pos
= strchr (bits_pos
, '*');
17089 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17091 u32 bits_len
= P_pos
- bits_pos
;
17095 char *enc_md_pos
= strchr (P_pos
, '*');
17097 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17099 u32 P_len
= enc_md_pos
- P_pos
;
17103 char *id_len_pos
= strchr (enc_md_pos
, '*');
17105 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17107 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17111 char *id_buf_pos
= strchr (id_len_pos
, '*');
17113 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17115 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17119 char *u_len_pos
= strchr (id_buf_pos
, '*');
17121 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17123 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17125 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17129 char *u_buf_pos
= strchr (u_len_pos
, '*');
17131 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17137 char *o_len_pos
= strchr (u_buf_pos
, '*');
17139 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17143 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17147 char *o_buf_pos
= strchr (o_len_pos
, '*');
17149 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17151 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17155 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;
17157 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17161 const int V
= atoi (V_pos
);
17162 const int R
= atoi (R_pos
);
17163 const int P
= atoi (P_pos
);
17165 if (V
!= 1) return (PARSER_SALT_VALUE
);
17166 if (R
!= 2) return (PARSER_SALT_VALUE
);
17168 const int enc_md
= atoi (enc_md_pos
);
17170 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17172 const int id_len
= atoi (id_len_pos
);
17173 const int u_len
= atoi (u_len_pos
);
17174 const int o_len
= atoi (o_len_pos
);
17176 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17177 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17178 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17180 const int bits
= atoi (bits_pos
);
17182 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17184 // copy data to esalt
17190 pdf
->enc_md
= enc_md
;
17192 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17193 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17194 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17195 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17196 pdf
->id_len
= id_len
;
17198 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17199 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17200 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17201 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17202 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17203 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17204 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17205 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17206 pdf
->u_len
= u_len
;
17208 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17209 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17210 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17211 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17212 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17213 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17214 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17215 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17216 pdf
->o_len
= o_len
;
17218 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17219 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17220 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17221 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17223 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17224 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17225 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17226 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17227 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17228 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17229 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17230 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17232 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17233 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17234 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17235 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17236 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17237 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17238 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17239 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17241 // we use ID for salt, maybe needs to change, we will see...
17243 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17244 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17245 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17246 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17247 salt
->salt_len
= pdf
->id_len
;
17249 digest
[0] = pdf
->u_buf
[0];
17250 digest
[1] = pdf
->u_buf
[1];
17251 digest
[2] = pdf
->u_buf
[2];
17252 digest
[3] = pdf
->u_buf
[3];
17254 return (PARSER_OK
);
17257 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17259 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17262 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17264 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17266 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17268 u32
*digest
= (u32
*) hash_buf
->digest
;
17270 salt_t
*salt
= hash_buf
->salt
;
17272 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17278 char *V_pos
= input_buf
+ 5;
17280 char *R_pos
= strchr (V_pos
, '*');
17282 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 u32 V_len
= R_pos
- V_pos
;
17288 char *bits_pos
= strchr (R_pos
, '*');
17290 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 u32 R_len
= bits_pos
- R_pos
;
17296 char *P_pos
= strchr (bits_pos
, '*');
17298 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 u32 bits_len
= P_pos
- bits_pos
;
17304 char *enc_md_pos
= strchr (P_pos
, '*');
17306 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 u32 P_len
= enc_md_pos
- P_pos
;
17312 char *id_len_pos
= strchr (enc_md_pos
, '*');
17314 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17316 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17320 char *id_buf_pos
= strchr (id_len_pos
, '*');
17322 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17324 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17328 char *u_len_pos
= strchr (id_buf_pos
, '*');
17330 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17332 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17334 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17338 char *u_buf_pos
= strchr (u_len_pos
, '*');
17340 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17346 char *o_len_pos
= strchr (u_buf_pos
, '*');
17348 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17350 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17352 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17356 char *o_buf_pos
= strchr (o_len_pos
, '*');
17358 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17364 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17366 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17370 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17374 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;
17376 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17380 const int V
= atoi (V_pos
);
17381 const int R
= atoi (R_pos
);
17382 const int P
= atoi (P_pos
);
17384 if (V
!= 1) return (PARSER_SALT_VALUE
);
17385 if (R
!= 2) return (PARSER_SALT_VALUE
);
17387 const int enc_md
= atoi (enc_md_pos
);
17389 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17391 const int id_len
= atoi (id_len_pos
);
17392 const int u_len
= atoi (u_len_pos
);
17393 const int o_len
= atoi (o_len_pos
);
17395 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17396 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17397 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17399 const int bits
= atoi (bits_pos
);
17401 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17403 // copy data to esalt
17409 pdf
->enc_md
= enc_md
;
17411 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17412 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17413 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17414 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17415 pdf
->id_len
= id_len
;
17417 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17418 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17419 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17420 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17421 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17422 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17423 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17424 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17425 pdf
->u_len
= u_len
;
17427 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17428 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17429 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17430 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17431 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17432 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17433 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17434 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17435 pdf
->o_len
= o_len
;
17437 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17438 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17439 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17440 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17442 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17443 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17444 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17445 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17446 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17447 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17448 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17449 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17451 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17452 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17453 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17454 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17455 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17456 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17457 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17458 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17460 pdf
->rc4key
[1] = 0;
17461 pdf
->rc4key
[0] = 0;
17463 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17464 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17465 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17466 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17467 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17468 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17469 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17470 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17471 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17472 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17474 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17475 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17477 // we use ID for salt, maybe needs to change, we will see...
17479 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17480 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17481 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17482 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17483 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17484 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17485 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17486 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17487 salt
->salt_len
= pdf
->id_len
+ 16;
17489 digest
[0] = pdf
->rc4key
[0];
17490 digest
[1] = pdf
->rc4key
[1];
17494 return (PARSER_OK
);
17497 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17499 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17501 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17503 u32
*digest
= (u32
*) hash_buf
->digest
;
17505 salt_t
*salt
= hash_buf
->salt
;
17507 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17513 char *V_pos
= input_buf
+ 5;
17515 char *R_pos
= strchr (V_pos
, '*');
17517 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17519 u32 V_len
= R_pos
- V_pos
;
17523 char *bits_pos
= strchr (R_pos
, '*');
17525 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17527 u32 R_len
= bits_pos
- R_pos
;
17531 char *P_pos
= strchr (bits_pos
, '*');
17533 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17535 u32 bits_len
= P_pos
- bits_pos
;
17539 char *enc_md_pos
= strchr (P_pos
, '*');
17541 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17543 u32 P_len
= enc_md_pos
- P_pos
;
17547 char *id_len_pos
= strchr (enc_md_pos
, '*');
17549 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17551 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17555 char *id_buf_pos
= strchr (id_len_pos
, '*');
17557 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17559 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17563 char *u_len_pos
= strchr (id_buf_pos
, '*');
17565 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17567 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17569 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17573 char *u_buf_pos
= strchr (u_len_pos
, '*');
17575 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17577 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17581 char *o_len_pos
= strchr (u_buf_pos
, '*');
17583 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17585 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17587 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17591 char *o_buf_pos
= strchr (o_len_pos
, '*');
17593 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17595 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17599 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;
17601 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17605 const int V
= atoi (V_pos
);
17606 const int R
= atoi (R_pos
);
17607 const int P
= atoi (P_pos
);
17611 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17612 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17614 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17616 const int id_len
= atoi (id_len_pos
);
17617 const int u_len
= atoi (u_len_pos
);
17618 const int o_len
= atoi (o_len_pos
);
17620 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17622 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17623 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17625 const int bits
= atoi (bits_pos
);
17627 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17633 enc_md
= atoi (enc_md_pos
);
17636 // copy data to esalt
17642 pdf
->enc_md
= enc_md
;
17644 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17645 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17646 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17647 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17651 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17652 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17653 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17654 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17657 pdf
->id_len
= id_len
;
17659 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17660 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17661 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17662 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17663 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17664 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17665 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17666 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17667 pdf
->u_len
= u_len
;
17669 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17670 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17671 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17672 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17673 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17674 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17675 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17676 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17677 pdf
->o_len
= o_len
;
17679 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17680 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17681 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17682 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17686 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17687 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17688 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17689 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17692 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17693 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17694 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17695 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17696 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17697 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17698 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17699 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17701 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17702 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17703 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17704 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17705 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17706 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17707 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17708 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17710 // precompute rc4 data for later use
17726 uint salt_pc_block
[32] = { 0 };
17728 char *salt_pc_ptr
= (char *) salt_pc_block
;
17730 memcpy (salt_pc_ptr
, padding
, 32);
17731 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17733 uint salt_pc_digest
[4] = { 0 };
17735 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17737 pdf
->rc4data
[0] = salt_pc_digest
[0];
17738 pdf
->rc4data
[1] = salt_pc_digest
[1];
17740 // we use ID for salt, maybe needs to change, we will see...
17742 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17743 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17744 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17745 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17746 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17747 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17748 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17749 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17750 salt
->salt_len
= pdf
->id_len
+ 16;
17752 salt
->salt_iter
= ROUNDS_PDF14
;
17754 digest
[0] = pdf
->u_buf
[0];
17755 digest
[1] = pdf
->u_buf
[1];
17759 return (PARSER_OK
);
17762 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17764 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17766 if (ret
!= PARSER_OK
)
17771 u32
*digest
= (u32
*) hash_buf
->digest
;
17773 salt_t
*salt
= hash_buf
->salt
;
17775 digest
[0] -= SHA256M_A
;
17776 digest
[1] -= SHA256M_B
;
17777 digest
[2] -= SHA256M_C
;
17778 digest
[3] -= SHA256M_D
;
17779 digest
[4] -= SHA256M_E
;
17780 digest
[5] -= SHA256M_F
;
17781 digest
[6] -= SHA256M_G
;
17782 digest
[7] -= SHA256M_H
;
17784 salt
->salt_buf
[2] = 0x80;
17786 return (PARSER_OK
);
17789 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17791 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17793 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17795 u32
*digest
= (u32
*) hash_buf
->digest
;
17797 salt_t
*salt
= hash_buf
->salt
;
17799 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17805 char *V_pos
= input_buf
+ 5;
17807 char *R_pos
= strchr (V_pos
, '*');
17809 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17811 u32 V_len
= R_pos
- V_pos
;
17815 char *bits_pos
= strchr (R_pos
, '*');
17817 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17819 u32 R_len
= bits_pos
- R_pos
;
17823 char *P_pos
= strchr (bits_pos
, '*');
17825 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17827 u32 bits_len
= P_pos
- bits_pos
;
17831 char *enc_md_pos
= strchr (P_pos
, '*');
17833 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17835 u32 P_len
= enc_md_pos
- P_pos
;
17839 char *id_len_pos
= strchr (enc_md_pos
, '*');
17841 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17843 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17847 char *id_buf_pos
= strchr (id_len_pos
, '*');
17849 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17851 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17855 char *u_len_pos
= strchr (id_buf_pos
, '*');
17857 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17859 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17863 char *u_buf_pos
= strchr (u_len_pos
, '*');
17865 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17867 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17871 char *o_len_pos
= strchr (u_buf_pos
, '*');
17873 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17875 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17879 char *o_buf_pos
= strchr (o_len_pos
, '*');
17881 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17883 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17887 char *last
= strchr (o_buf_pos
, '*');
17889 if (last
== NULL
) last
= input_buf
+ input_len
;
17891 u32 o_buf_len
= last
- o_buf_pos
;
17895 const int V
= atoi (V_pos
);
17896 const int R
= atoi (R_pos
);
17900 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17901 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17903 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17905 const int bits
= atoi (bits_pos
);
17907 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17909 int enc_md
= atoi (enc_md_pos
);
17911 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17913 const uint id_len
= atoi (id_len_pos
);
17914 const uint u_len
= atoi (u_len_pos
);
17915 const uint o_len
= atoi (o_len_pos
);
17917 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17918 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17919 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17920 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17921 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17922 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17923 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17924 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17926 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17927 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17928 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17930 // copy data to esalt
17932 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17934 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17936 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17939 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17940 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17942 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17943 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17945 salt
->salt_len
= 8;
17946 salt
->salt_iter
= ROUNDS_PDF17L8
;
17948 digest
[0] = pdf
->u_buf
[0];
17949 digest
[1] = pdf
->u_buf
[1];
17950 digest
[2] = pdf
->u_buf
[2];
17951 digest
[3] = pdf
->u_buf
[3];
17952 digest
[4] = pdf
->u_buf
[4];
17953 digest
[5] = pdf
->u_buf
[5];
17954 digest
[6] = pdf
->u_buf
[6];
17955 digest
[7] = pdf
->u_buf
[7];
17957 return (PARSER_OK
);
17960 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17962 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17964 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17966 u32
*digest
= (u32
*) hash_buf
->digest
;
17968 salt_t
*salt
= hash_buf
->salt
;
17970 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17978 char *iter_pos
= input_buf
+ 7;
17980 u32 iter
= atoi (iter_pos
);
17982 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17983 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17985 // first is *raw* salt
17987 char *salt_pos
= strchr (iter_pos
, ':');
17989 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17993 char *hash_pos
= strchr (salt_pos
, ':');
17995 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17997 u32 salt_len
= hash_pos
- salt_pos
;
17999 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18003 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18005 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18009 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18011 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18013 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18015 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18016 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18018 salt
->salt_len
= salt_len
;
18019 salt
->salt_iter
= iter
- 1;
18023 u8 tmp_buf
[100] = { 0 };
18025 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18027 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18029 memcpy (digest
, tmp_buf
, 16);
18031 digest
[0] = byte_swap_32 (digest
[0]);
18032 digest
[1] = byte_swap_32 (digest
[1]);
18033 digest
[2] = byte_swap_32 (digest
[2]);
18034 digest
[3] = byte_swap_32 (digest
[3]);
18036 // add some stuff to normal salt to make sorted happy
18038 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18039 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18040 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18041 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18042 salt
->salt_buf
[4] = salt
->salt_iter
;
18044 return (PARSER_OK
);
18047 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18049 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18051 u32
*digest
= (u32
*) hash_buf
->digest
;
18053 salt_t
*salt
= hash_buf
->salt
;
18055 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18056 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18057 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18058 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18060 digest
[0] = byte_swap_32 (digest
[0]);
18061 digest
[1] = byte_swap_32 (digest
[1]);
18062 digest
[2] = byte_swap_32 (digest
[2]);
18063 digest
[3] = byte_swap_32 (digest
[3]);
18065 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18067 uint salt_len
= input_len
- 32 - 1;
18069 char *salt_buf
= input_buf
+ 32 + 1;
18071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18073 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18075 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18077 salt
->salt_len
= salt_len
;
18079 return (PARSER_OK
);
18082 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18084 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18086 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18088 u32
*digest
= (u32
*) hash_buf
->digest
;
18090 salt_t
*salt
= hash_buf
->salt
;
18092 char *user_pos
= input_buf
+ 10;
18094 char *salt_pos
= strchr (user_pos
, '*');
18096 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18100 char *hash_pos
= strchr (salt_pos
, '*');
18104 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18106 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18108 uint user_len
= salt_pos
- user_pos
- 1;
18110 uint salt_len
= hash_pos
- salt_pos
- 1;
18112 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18118 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18119 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18120 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18121 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18123 digest
[0] = byte_swap_32 (digest
[0]);
18124 digest
[1] = byte_swap_32 (digest
[1]);
18125 digest
[2] = byte_swap_32 (digest
[2]);
18126 digest
[3] = byte_swap_32 (digest
[3]);
18128 digest
[0] -= MD5M_A
;
18129 digest
[1] -= MD5M_B
;
18130 digest
[2] -= MD5M_C
;
18131 digest
[3] -= MD5M_D
;
18137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18139 // first 4 bytes are the "challenge"
18141 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18142 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18143 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18144 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18146 // append the user name
18148 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18150 salt
->salt_len
= 4 + user_len
;
18152 return (PARSER_OK
);
18155 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18157 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18159 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18161 u32
*digest
= (u32
*) hash_buf
->digest
;
18163 salt_t
*salt
= hash_buf
->salt
;
18165 char *salt_pos
= input_buf
+ 9;
18167 char *hash_pos
= strchr (salt_pos
, '*');
18169 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18173 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18175 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18177 uint salt_len
= hash_pos
- salt_pos
- 1;
18179 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18185 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18186 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18187 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18188 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18189 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18199 salt
->salt_len
= salt_len
;
18201 return (PARSER_OK
);
18204 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18206 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18208 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18210 u32
*digest
= (u32
*) hash_buf
->digest
;
18212 salt_t
*salt
= hash_buf
->salt
;
18214 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18220 char *cry_master_len_pos
= input_buf
+ 9;
18222 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18224 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18226 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18228 cry_master_buf_pos
++;
18230 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18232 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18234 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18236 cry_salt_len_pos
++;
18238 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18240 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18242 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18244 cry_salt_buf_pos
++;
18246 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18248 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18250 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18254 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18256 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18258 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18262 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18264 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18266 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18270 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18272 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18274 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18276 public_key_len_pos
++;
18278 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18280 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18282 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18284 public_key_buf_pos
++;
18286 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;
18288 const uint cry_master_len
= atoi (cry_master_len_pos
);
18289 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18290 const uint ckey_len
= atoi (ckey_len_pos
);
18291 const uint public_key_len
= atoi (public_key_len_pos
);
18293 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18294 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18295 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18296 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18298 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18300 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18302 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18305 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18307 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18309 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18312 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18314 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18316 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18319 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18320 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18321 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18324 * store digest (should be unique enought, hopefully)
18327 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18328 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18329 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18330 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18336 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18338 const uint cry_rounds
= atoi (cry_rounds_pos
);
18340 salt
->salt_iter
= cry_rounds
- 1;
18342 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18344 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18346 salt
->salt_len
= salt_len
;
18348 return (PARSER_OK
);
18351 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18353 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18355 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18357 u32
*digest
= (u32
*) hash_buf
->digest
;
18359 salt_t
*salt
= hash_buf
->salt
;
18361 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18363 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18365 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18367 memcpy (temp_input_buf
, input_buf
, input_len
);
18371 char *URI_server_pos
= temp_input_buf
+ 6;
18373 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18375 if (URI_client_pos
== NULL
)
18377 myfree (temp_input_buf
);
18379 return (PARSER_SEPARATOR_UNMATCHED
);
18382 URI_client_pos
[0] = 0;
18385 uint URI_server_len
= strlen (URI_server_pos
);
18387 if (URI_server_len
> 512)
18389 myfree (temp_input_buf
);
18391 return (PARSER_SALT_LENGTH
);
18396 char *user_pos
= strchr (URI_client_pos
, '*');
18398 if (user_pos
== NULL
)
18400 myfree (temp_input_buf
);
18402 return (PARSER_SEPARATOR_UNMATCHED
);
18408 uint URI_client_len
= strlen (URI_client_pos
);
18410 if (URI_client_len
> 512)
18412 myfree (temp_input_buf
);
18414 return (PARSER_SALT_LENGTH
);
18419 char *realm_pos
= strchr (user_pos
, '*');
18421 if (realm_pos
== NULL
)
18423 myfree (temp_input_buf
);
18425 return (PARSER_SEPARATOR_UNMATCHED
);
18431 uint user_len
= strlen (user_pos
);
18433 if (user_len
> 116)
18435 myfree (temp_input_buf
);
18437 return (PARSER_SALT_LENGTH
);
18442 char *method_pos
= strchr (realm_pos
, '*');
18444 if (method_pos
== NULL
)
18446 myfree (temp_input_buf
);
18448 return (PARSER_SEPARATOR_UNMATCHED
);
18454 uint realm_len
= strlen (realm_pos
);
18456 if (realm_len
> 116)
18458 myfree (temp_input_buf
);
18460 return (PARSER_SALT_LENGTH
);
18465 char *URI_prefix_pos
= strchr (method_pos
, '*');
18467 if (URI_prefix_pos
== NULL
)
18469 myfree (temp_input_buf
);
18471 return (PARSER_SEPARATOR_UNMATCHED
);
18474 URI_prefix_pos
[0] = 0;
18477 uint method_len
= strlen (method_pos
);
18479 if (method_len
> 246)
18481 myfree (temp_input_buf
);
18483 return (PARSER_SALT_LENGTH
);
18488 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18490 if (URI_resource_pos
== NULL
)
18492 myfree (temp_input_buf
);
18494 return (PARSER_SEPARATOR_UNMATCHED
);
18497 URI_resource_pos
[0] = 0;
18498 URI_resource_pos
++;
18500 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18502 if (URI_prefix_len
> 245)
18504 myfree (temp_input_buf
);
18506 return (PARSER_SALT_LENGTH
);
18511 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18513 if (URI_suffix_pos
== NULL
)
18515 myfree (temp_input_buf
);
18517 return (PARSER_SEPARATOR_UNMATCHED
);
18520 URI_suffix_pos
[0] = 0;
18523 uint URI_resource_len
= strlen (URI_resource_pos
);
18525 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18527 myfree (temp_input_buf
);
18529 return (PARSER_SALT_LENGTH
);
18534 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18536 if (nonce_pos
== NULL
)
18538 myfree (temp_input_buf
);
18540 return (PARSER_SEPARATOR_UNMATCHED
);
18546 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18548 if (URI_suffix_len
> 245)
18550 myfree (temp_input_buf
);
18552 return (PARSER_SALT_LENGTH
);
18557 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18559 if (nonce_client_pos
== NULL
)
18561 myfree (temp_input_buf
);
18563 return (PARSER_SEPARATOR_UNMATCHED
);
18566 nonce_client_pos
[0] = 0;
18567 nonce_client_pos
++;
18569 uint nonce_len
= strlen (nonce_pos
);
18571 if (nonce_len
< 1 || nonce_len
> 50)
18573 myfree (temp_input_buf
);
18575 return (PARSER_SALT_LENGTH
);
18580 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18582 if (nonce_count_pos
== NULL
)
18584 myfree (temp_input_buf
);
18586 return (PARSER_SEPARATOR_UNMATCHED
);
18589 nonce_count_pos
[0] = 0;
18592 uint nonce_client_len
= strlen (nonce_client_pos
);
18594 if (nonce_client_len
> 50)
18596 myfree (temp_input_buf
);
18598 return (PARSER_SALT_LENGTH
);
18603 char *qop_pos
= strchr (nonce_count_pos
, '*');
18605 if (qop_pos
== NULL
)
18607 myfree (temp_input_buf
);
18609 return (PARSER_SEPARATOR_UNMATCHED
);
18615 uint nonce_count_len
= strlen (nonce_count_pos
);
18617 if (nonce_count_len
> 50)
18619 myfree (temp_input_buf
);
18621 return (PARSER_SALT_LENGTH
);
18626 char *directive_pos
= strchr (qop_pos
, '*');
18628 if (directive_pos
== NULL
)
18630 myfree (temp_input_buf
);
18632 return (PARSER_SEPARATOR_UNMATCHED
);
18635 directive_pos
[0] = 0;
18638 uint qop_len
= strlen (qop_pos
);
18642 myfree (temp_input_buf
);
18644 return (PARSER_SALT_LENGTH
);
18649 char *digest_pos
= strchr (directive_pos
, '*');
18651 if (digest_pos
== NULL
)
18653 myfree (temp_input_buf
);
18655 return (PARSER_SEPARATOR_UNMATCHED
);
18661 uint directive_len
= strlen (directive_pos
);
18663 if (directive_len
!= 3)
18665 myfree (temp_input_buf
);
18667 return (PARSER_SALT_LENGTH
);
18670 if (memcmp (directive_pos
, "MD5", 3))
18672 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18674 myfree (temp_input_buf
);
18676 return (PARSER_SIP_AUTH_DIRECTIVE
);
18680 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18685 uint md5_max_len
= 4 * 64;
18687 uint md5_remaining_len
= md5_max_len
;
18689 uint tmp_md5_buf
[64] = { 0 };
18691 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18693 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18695 md5_len
+= method_len
+ 1;
18696 tmp_md5_ptr
+= method_len
+ 1;
18698 if (URI_prefix_len
> 0)
18700 md5_remaining_len
= md5_max_len
- md5_len
;
18702 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18704 md5_len
+= URI_prefix_len
+ 1;
18705 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18708 md5_remaining_len
= md5_max_len
- md5_len
;
18710 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18712 md5_len
+= URI_resource_len
;
18713 tmp_md5_ptr
+= URI_resource_len
;
18715 if (URI_suffix_len
> 0)
18717 md5_remaining_len
= md5_max_len
- md5_len
;
18719 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18721 md5_len
+= 1 + URI_suffix_len
;
18724 uint tmp_digest
[4] = { 0 };
18726 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18728 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18729 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18730 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18731 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18737 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18739 uint esalt_len
= 0;
18741 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18743 // there are 2 possibilities for the esalt:
18745 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18747 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18749 if (esalt_len
> max_esalt_len
)
18751 myfree (temp_input_buf
);
18753 return (PARSER_SALT_LENGTH
);
18756 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18768 esalt_len
= 1 + nonce_len
+ 1 + 32;
18770 if (esalt_len
> max_esalt_len
)
18772 myfree (temp_input_buf
);
18774 return (PARSER_SALT_LENGTH
);
18777 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18785 // add 0x80 to esalt
18787 esalt_buf_ptr
[esalt_len
] = 0x80;
18789 sip
->esalt_len
= esalt_len
;
18795 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18797 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18799 uint max_salt_len
= 119;
18801 if (salt_len
> max_salt_len
)
18803 myfree (temp_input_buf
);
18805 return (PARSER_SALT_LENGTH
);
18808 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18810 sip
->salt_len
= salt_len
;
18813 * fake salt (for sorting)
18816 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18820 uint fake_salt_len
= salt_len
;
18822 if (fake_salt_len
> max_salt_len
)
18824 fake_salt_len
= max_salt_len
;
18827 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18829 salt
->salt_len
= fake_salt_len
;
18835 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18836 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18837 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18838 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18840 digest
[0] = byte_swap_32 (digest
[0]);
18841 digest
[1] = byte_swap_32 (digest
[1]);
18842 digest
[2] = byte_swap_32 (digest
[2]);
18843 digest
[3] = byte_swap_32 (digest
[3]);
18845 myfree (temp_input_buf
);
18847 return (PARSER_OK
);
18850 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18852 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18854 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18856 u32
*digest
= (u32
*) hash_buf
->digest
;
18858 salt_t
*salt
= hash_buf
->salt
;
18862 char *digest_pos
= input_buf
;
18864 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18871 char *salt_buf
= input_buf
+ 8 + 1;
18875 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18877 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18879 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18881 salt
->salt_len
= salt_len
;
18883 return (PARSER_OK
);
18886 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18888 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18890 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18892 u32
*digest
= (u32
*) hash_buf
->digest
;
18894 salt_t
*salt
= hash_buf
->salt
;
18896 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18902 char *p_buf_pos
= input_buf
+ 4;
18904 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18906 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18908 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18910 NumCyclesPower_pos
++;
18912 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18914 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18916 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18920 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18922 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18924 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18928 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18930 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18932 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18936 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18938 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18940 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18944 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18946 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18948 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18952 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18954 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18956 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18960 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18962 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18964 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18968 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18970 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18972 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18976 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;
18978 const uint iter
= atoi (NumCyclesPower_pos
);
18979 const uint crc
= atoi (crc_buf_pos
);
18980 const uint p_buf
= atoi (p_buf_pos
);
18981 const uint salt_len
= atoi (salt_len_pos
);
18982 const uint iv_len
= atoi (iv_len_pos
);
18983 const uint unpack_size
= atoi (unpack_size_pos
);
18984 const uint data_len
= atoi (data_len_pos
);
18990 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18991 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18993 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18995 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18997 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
19003 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19004 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19005 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19006 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19008 seven_zip
->iv_len
= iv_len
;
19010 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19012 seven_zip
->salt_len
= 0;
19014 seven_zip
->crc
= crc
;
19016 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19018 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19020 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19023 seven_zip
->data_len
= data_len
;
19025 seven_zip
->unpack_size
= unpack_size
;
19029 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19030 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19031 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19032 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19034 salt
->salt_len
= 16;
19036 salt
->salt_sign
[0] = iter
;
19038 salt
->salt_iter
= 1 << iter
;
19049 return (PARSER_OK
);
19052 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19054 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19056 u32
*digest
= (u32
*) hash_buf
->digest
;
19058 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19059 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19060 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19061 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19062 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19063 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19064 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19065 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19067 digest
[0] = byte_swap_32 (digest
[0]);
19068 digest
[1] = byte_swap_32 (digest
[1]);
19069 digest
[2] = byte_swap_32 (digest
[2]);
19070 digest
[3] = byte_swap_32 (digest
[3]);
19071 digest
[4] = byte_swap_32 (digest
[4]);
19072 digest
[5] = byte_swap_32 (digest
[5]);
19073 digest
[6] = byte_swap_32 (digest
[6]);
19074 digest
[7] = byte_swap_32 (digest
[7]);
19076 return (PARSER_OK
);
19079 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19081 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19083 u32
*digest
= (u32
*) hash_buf
->digest
;
19085 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19086 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19087 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19088 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19089 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19090 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19091 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19092 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19093 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19094 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19095 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19096 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19097 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19098 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19099 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19100 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19102 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19103 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19104 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19105 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19106 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19107 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19108 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19109 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19110 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19111 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19112 digest
[10] = byte_swap_32 (digest
[10]);
19113 digest
[11] = byte_swap_32 (digest
[11]);
19114 digest
[12] = byte_swap_32 (digest
[12]);
19115 digest
[13] = byte_swap_32 (digest
[13]);
19116 digest
[14] = byte_swap_32 (digest
[14]);
19117 digest
[15] = byte_swap_32 (digest
[15]);
19119 return (PARSER_OK
);
19122 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19124 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19126 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19128 u32
*digest
= (u32
*) hash_buf
->digest
;
19130 salt_t
*salt
= hash_buf
->salt
;
19132 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19140 char *iter_pos
= input_buf
+ 4;
19142 u32 iter
= atoi (iter_pos
);
19144 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19145 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19147 // first is *raw* salt
19149 char *salt_pos
= strchr (iter_pos
, ':');
19151 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19155 char *hash_pos
= strchr (salt_pos
, ':');
19157 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19159 u32 salt_len
= hash_pos
- salt_pos
;
19161 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19165 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19167 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19171 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19173 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19175 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19177 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19178 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19180 salt
->salt_len
= salt_len
;
19181 salt
->salt_iter
= iter
- 1;
19185 u8 tmp_buf
[100] = { 0 };
19187 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19189 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19191 memcpy (digest
, tmp_buf
, 16);
19193 // add some stuff to normal salt to make sorted happy
19195 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19196 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19197 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19198 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19199 salt
->salt_buf
[4] = salt
->salt_iter
;
19201 return (PARSER_OK
);
19204 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19206 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19208 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19210 u32
*digest
= (u32
*) hash_buf
->digest
;
19212 salt_t
*salt
= hash_buf
->salt
;
19214 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19222 char *iter_pos
= input_buf
+ 5;
19224 u32 iter
= atoi (iter_pos
);
19226 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19227 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19229 // first is *raw* salt
19231 char *salt_pos
= strchr (iter_pos
, ':');
19233 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19237 char *hash_pos
= strchr (salt_pos
, ':');
19239 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19241 u32 salt_len
= hash_pos
- salt_pos
;
19243 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19247 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19249 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19253 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19259 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19260 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19262 salt
->salt_len
= salt_len
;
19263 salt
->salt_iter
= iter
- 1;
19267 u8 tmp_buf
[100] = { 0 };
19269 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19271 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19273 memcpy (digest
, tmp_buf
, 16);
19275 digest
[0] = byte_swap_32 (digest
[0]);
19276 digest
[1] = byte_swap_32 (digest
[1]);
19277 digest
[2] = byte_swap_32 (digest
[2]);
19278 digest
[3] = byte_swap_32 (digest
[3]);
19280 // add some stuff to normal salt to make sorted happy
19282 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19283 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19284 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19285 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19286 salt
->salt_buf
[4] = salt
->salt_iter
;
19288 return (PARSER_OK
);
19291 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19293 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19295 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19297 u64
*digest
= (u64
*) hash_buf
->digest
;
19299 salt_t
*salt
= hash_buf
->salt
;
19301 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19309 char *iter_pos
= input_buf
+ 7;
19311 u32 iter
= atoi (iter_pos
);
19313 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19314 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19316 // first is *raw* salt
19318 char *salt_pos
= strchr (iter_pos
, ':');
19320 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19324 char *hash_pos
= strchr (salt_pos
, ':');
19326 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19328 u32 salt_len
= hash_pos
- salt_pos
;
19330 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19334 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19336 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19340 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19346 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19347 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19349 salt
->salt_len
= salt_len
;
19350 salt
->salt_iter
= iter
- 1;
19354 u8 tmp_buf
[100] = { 0 };
19356 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19358 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19360 memcpy (digest
, tmp_buf
, 64);
19362 digest
[0] = byte_swap_64 (digest
[0]);
19363 digest
[1] = byte_swap_64 (digest
[1]);
19364 digest
[2] = byte_swap_64 (digest
[2]);
19365 digest
[3] = byte_swap_64 (digest
[3]);
19366 digest
[4] = byte_swap_64 (digest
[4]);
19367 digest
[5] = byte_swap_64 (digest
[5]);
19368 digest
[6] = byte_swap_64 (digest
[6]);
19369 digest
[7] = byte_swap_64 (digest
[7]);
19371 // add some stuff to normal salt to make sorted happy
19373 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19374 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19375 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19376 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19377 salt
->salt_buf
[4] = salt
->salt_iter
;
19379 return (PARSER_OK
);
19382 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19384 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19386 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19388 uint
*digest
= (uint
*) hash_buf
->digest
;
19390 salt_t
*salt
= hash_buf
->salt
;
19396 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19398 char *hash_pos
= strchr (salt_pos
, '$');
19400 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19402 u32 salt_len
= hash_pos
- salt_pos
;
19404 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19408 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19410 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19414 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19415 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19433 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19434 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19436 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19437 salt
->salt_len
= 8;
19439 return (PARSER_OK
);
19442 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19444 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19446 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19448 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19450 if (c19
& 3) return (PARSER_HASH_VALUE
);
19452 salt_t
*salt
= hash_buf
->salt
;
19454 u32
*digest
= (u32
*) hash_buf
->digest
;
19458 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19459 | itoa64_to_int (input_buf
[2]) << 6
19460 | itoa64_to_int (input_buf
[3]) << 12
19461 | itoa64_to_int (input_buf
[4]) << 18;
19465 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19466 | itoa64_to_int (input_buf
[6]) << 6
19467 | itoa64_to_int (input_buf
[7]) << 12
19468 | itoa64_to_int (input_buf
[8]) << 18;
19470 salt
->salt_len
= 4;
19472 u8 tmp_buf
[100] = { 0 };
19474 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19476 memcpy (digest
, tmp_buf
, 8);
19480 IP (digest
[0], digest
[1], tt
);
19482 digest
[0] = rotr32 (digest
[0], 31);
19483 digest
[1] = rotr32 (digest
[1], 31);
19487 return (PARSER_OK
);
19490 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19492 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19494 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19496 u32
*digest
= (u32
*) hash_buf
->digest
;
19498 salt_t
*salt
= hash_buf
->salt
;
19504 char *type_pos
= input_buf
+ 6 + 1;
19506 char *salt_pos
= strchr (type_pos
, '*');
19508 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19510 u32 type_len
= salt_pos
- type_pos
;
19512 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19516 char *crypted_pos
= strchr (salt_pos
, '*');
19518 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19520 u32 salt_len
= crypted_pos
- salt_pos
;
19522 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19526 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19528 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19534 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19535 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19537 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19538 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19540 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19541 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19542 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19543 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19545 salt
->salt_len
= 24;
19546 salt
->salt_iter
= ROUNDS_RAR3
;
19548 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19549 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19551 digest
[0] = 0xc43d7b00;
19552 digest
[1] = 0x40070000;
19556 return (PARSER_OK
);
19559 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19561 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19563 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19565 u32
*digest
= (u32
*) hash_buf
->digest
;
19567 salt_t
*salt
= hash_buf
->salt
;
19569 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19575 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19577 char *param1_pos
= strchr (param0_pos
, '$');
19579 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19581 u32 param0_len
= param1_pos
- param0_pos
;
19585 char *param2_pos
= strchr (param1_pos
, '$');
19587 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19589 u32 param1_len
= param2_pos
- param1_pos
;
19593 char *param3_pos
= strchr (param2_pos
, '$');
19595 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19597 u32 param2_len
= param3_pos
- param2_pos
;
19601 char *param4_pos
= strchr (param3_pos
, '$');
19603 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19605 u32 param3_len
= param4_pos
- param3_pos
;
19609 char *param5_pos
= strchr (param4_pos
, '$');
19611 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19613 u32 param4_len
= param5_pos
- param4_pos
;
19617 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19619 char *salt_buf
= param1_pos
;
19620 char *iv
= param3_pos
;
19621 char *pswcheck
= param5_pos
;
19623 const uint salt_len
= atoi (param0_pos
);
19624 const uint iterations
= atoi (param2_pos
);
19625 const uint pswcheck_len
= atoi (param4_pos
);
19631 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19632 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19633 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19635 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19636 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19637 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19643 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19644 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19645 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19646 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19648 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19649 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19650 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19651 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19653 salt
->salt_len
= 16;
19655 salt
->salt_sign
[0] = iterations
;
19657 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19663 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19664 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19668 return (PARSER_OK
);
19671 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19673 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19675 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19677 u32
*digest
= (u32
*) hash_buf
->digest
;
19679 salt_t
*salt
= hash_buf
->salt
;
19681 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19688 char *account_pos
= input_buf
+ 11 + 1;
19694 if (account_pos
[0] == '*')
19698 data_pos
= strchr (account_pos
, '*');
19703 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19705 uint account_len
= data_pos
- account_pos
+ 1;
19707 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19712 data_len
= input_len
- 11 - 1 - account_len
- 2;
19714 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19718 /* assume $krb5tgs$23$checksum$edata2 */
19719 data_pos
= account_pos
;
19721 memcpy (krb5tgs
->account_info
, "**", 3);
19723 data_len
= input_len
- 11 - 1 - 1;
19726 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19728 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19730 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19732 const char p0
= data_pos
[i
+ 0];
19733 const char p1
= data_pos
[i
+ 1];
19735 *checksum_ptr
++ = hex_convert (p1
) << 0
19736 | hex_convert (p0
) << 4;
19739 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19741 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19744 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19746 const char p0
= data_pos
[i
+ 0];
19747 const char p1
= data_pos
[i
+ 1];
19748 *edata_ptr
++ = hex_convert (p1
) << 0
19749 | hex_convert (p0
) << 4;
19752 /* this is needed for hmac_md5 */
19753 *edata_ptr
++ = 0x80;
19755 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19756 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19757 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19758 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19760 salt
->salt_len
= 32;
19762 digest
[0] = krb5tgs
->checksum
[0];
19763 digest
[1] = krb5tgs
->checksum
[1];
19764 digest
[2] = krb5tgs
->checksum
[2];
19765 digest
[3] = krb5tgs
->checksum
[3];
19767 return (PARSER_OK
);
19770 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19772 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19774 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19776 u32
*digest
= (u32
*) hash_buf
->digest
;
19778 salt_t
*salt
= hash_buf
->salt
;
19785 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19789 char *wrapped_key_pos
;
19793 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19795 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19797 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19799 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19804 data_pos
= salt_pos
;
19806 wrapped_key_pos
= strchr (salt_pos
, '*');
19808 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19810 uint salt_len
= wrapped_key_pos
- salt_pos
;
19812 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19817 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19819 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19821 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19822 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19823 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19824 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19828 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19829 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19830 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19831 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19832 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19833 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19835 salt
->salt_len
= 40;
19837 digest
[0] = salt
->salt_buf
[0];
19838 digest
[1] = salt
->salt_buf
[1];
19839 digest
[2] = salt
->salt_buf
[2];
19840 digest
[3] = salt
->salt_buf
[3];
19842 return (PARSER_OK
);
19845 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19847 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19849 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19851 u32
*digest
= (u32
*) hash_buf
->digest
;
19853 salt_t
*salt
= hash_buf
->salt
;
19855 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19865 char *algorithm_pos
;
19867 char *final_random_seed_pos
;
19868 u32 final_random_seed_len
;
19870 char *transf_random_seed_pos
;
19871 u32 transf_random_seed_len
;
19876 /* default is no keyfile provided */
19877 char *keyfile_len_pos
;
19878 u32 keyfile_len
= 0;
19879 u32 is_keyfile_present
= 0;
19880 char *keyfile_inline_pos
;
19883 /* specific to version 1 */
19884 char *contents_len_pos
;
19886 char *contents_pos
;
19888 /* specific to version 2 */
19889 char *expected_bytes_pos
;
19890 u32 expected_bytes_len
;
19892 char *contents_hash_pos
;
19893 u32 contents_hash_len
;
19895 version_pos
= input_buf
+ 8 + 1 + 1;
19897 keepass
->version
= atoi (version_pos
);
19899 rounds_pos
= strchr (version_pos
, '*');
19901 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19905 salt
->salt_iter
= (atoi (rounds_pos
));
19907 algorithm_pos
= strchr (rounds_pos
, '*');
19909 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19913 keepass
->algorithm
= atoi (algorithm_pos
);
19915 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19917 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19919 final_random_seed_pos
++;
19921 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19922 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19923 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19924 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19926 if (keepass
->version
== 2)
19928 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19929 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19930 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19931 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19934 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19936 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19938 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19940 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19941 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19943 transf_random_seed_pos
++;
19945 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19946 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19947 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19948 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19949 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19950 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19951 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19952 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19954 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19956 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19958 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19960 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19964 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19965 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19966 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19967 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19969 if (keepass
->version
== 1)
19971 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19973 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19975 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19977 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19979 contents_hash_pos
++;
19981 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19982 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19983 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19984 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19985 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19986 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19987 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19988 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19990 /* get length of contents following */
19991 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19993 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19995 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19997 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20001 u32 inline_flag
= atoi (inline_flag_pos
);
20003 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20005 contents_len_pos
= strchr (inline_flag_pos
, '*');
20007 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20009 contents_len_pos
++;
20011 contents_len
= atoi (contents_len_pos
);
20013 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20015 contents_pos
= strchr (contents_len_pos
, '*');
20017 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20023 keepass
->contents_len
= contents_len
;
20025 contents_len
= contents_len
/ 4;
20027 keyfile_inline_pos
= strchr (contents_pos
, '*');
20029 u32 real_contents_len
;
20031 if (keyfile_inline_pos
== NULL
)
20032 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20035 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20036 keyfile_inline_pos
++;
20037 is_keyfile_present
= 1;
20040 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20042 for (i
= 0; i
< contents_len
; i
++)
20043 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20045 else if (keepass
->version
== 2)
20047 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20049 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20051 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20053 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20055 expected_bytes_pos
++;
20057 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20058 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20059 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20060 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20061 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20062 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20063 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20064 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20066 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20068 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20070 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20072 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20074 contents_hash_pos
++;
20076 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20077 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20078 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20079 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20080 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20081 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20082 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20083 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20085 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20087 if (keyfile_inline_pos
== NULL
)
20088 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20091 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20092 keyfile_inline_pos
++;
20093 is_keyfile_present
= 1;
20095 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20098 if (is_keyfile_present
!= 0)
20100 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20104 keyfile_len
= atoi (keyfile_len_pos
);
20106 keepass
->keyfile_len
= keyfile_len
;
20108 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20110 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20112 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20116 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20118 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20120 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20121 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20122 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20123 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20124 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20125 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20126 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20127 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20130 digest
[0] = keepass
->enc_iv
[0];
20131 digest
[1] = keepass
->enc_iv
[1];
20132 digest
[2] = keepass
->enc_iv
[2];
20133 digest
[3] = keepass
->enc_iv
[3];
20135 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20136 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20137 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20138 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20139 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20140 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20141 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20142 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20144 return (PARSER_OK
);
20147 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20149 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20151 u32
*digest
= (u32
*) hash_buf
->digest
;
20153 salt_t
*salt
= hash_buf
->salt
;
20155 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20156 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20157 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20158 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20159 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20160 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20161 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20162 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20164 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20166 uint salt_len
= input_len
- 64 - 1;
20168 char *salt_buf
= input_buf
+ 64 + 1;
20170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20176 salt
->salt_len
= salt_len
;
20179 * we can precompute the first sha256 transform
20182 uint w
[16] = { 0 };
20184 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20185 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20186 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20187 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20188 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20189 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20190 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20191 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20192 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20193 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20194 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20195 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20196 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20197 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20198 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20199 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20201 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20203 sha256_64 (w
, pc256
);
20205 salt
->salt_buf_pc
[0] = pc256
[0];
20206 salt
->salt_buf_pc
[1] = pc256
[1];
20207 salt
->salt_buf_pc
[2] = pc256
[2];
20208 salt
->salt_buf_pc
[3] = pc256
[3];
20209 salt
->salt_buf_pc
[4] = pc256
[4];
20210 salt
->salt_buf_pc
[5] = pc256
[5];
20211 salt
->salt_buf_pc
[6] = pc256
[6];
20212 salt
->salt_buf_pc
[7] = pc256
[7];
20214 digest
[0] -= pc256
[0];
20215 digest
[1] -= pc256
[1];
20216 digest
[2] -= pc256
[2];
20217 digest
[3] -= pc256
[3];
20218 digest
[4] -= pc256
[4];
20219 digest
[5] -= pc256
[5];
20220 digest
[6] -= pc256
[6];
20221 digest
[7] -= pc256
[7];
20223 return (PARSER_OK
);
20226 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20228 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20230 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20232 u32
*digest
= (u32
*) hash_buf
->digest
;
20234 salt_t
*salt
= hash_buf
->salt
;
20240 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20242 char *data_buf_pos
= strchr (data_len_pos
, '$');
20244 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20246 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20248 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20249 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20253 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20255 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20257 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20259 u32 data_len
= atoi (data_len_pos
);
20261 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20267 char *salt_pos
= data_buf_pos
;
20269 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20270 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20271 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20272 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20274 // this is actually the CT, which is also the hash later (if matched)
20276 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20277 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20278 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20279 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20281 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20283 salt
->salt_iter
= 10 - 1;
20289 digest
[0] = salt
->salt_buf
[4];
20290 digest
[1] = salt
->salt_buf
[5];
20291 digest
[2] = salt
->salt_buf
[6];
20292 digest
[3] = salt
->salt_buf
[7];
20294 return (PARSER_OK
);
20297 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20299 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20301 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20303 u32
*digest
= (u32
*) hash_buf
->digest
;
20305 salt_t
*salt
= hash_buf
->salt
;
20311 char *salt_pos
= input_buf
+ 11 + 1;
20313 char *iter_pos
= strchr (salt_pos
, ',');
20315 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20317 u32 salt_len
= iter_pos
- salt_pos
;
20319 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20323 char *hash_pos
= strchr (iter_pos
, ',');
20325 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20327 u32 iter_len
= hash_pos
- iter_pos
;
20329 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20333 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20335 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20341 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20342 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20343 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20344 salt
->salt_buf
[3] = 0x00018000;
20346 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20347 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20348 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20349 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20351 salt
->salt_len
= salt_len
/ 2;
20353 salt
->salt_iter
= atoi (iter_pos
) - 1;
20359 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20360 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20361 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20362 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20363 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20364 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20365 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20366 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20368 return (PARSER_OK
);
20371 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20373 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20375 u32
*digest
= (u32
*) hash_buf
->digest
;
20377 salt_t
*salt
= hash_buf
->salt
;
20383 char *hash_pos
= input_buf
+ 64;
20384 char *salt1_pos
= input_buf
+ 128;
20385 char *salt2_pos
= input_buf
;
20391 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20392 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20393 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20394 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20396 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20397 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20398 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20399 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20401 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20402 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20403 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20404 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20406 salt
->salt_len
= 48;
20408 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20414 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20415 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20416 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20417 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20418 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20419 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20420 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20421 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20423 return (PARSER_OK
);
20426 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20428 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20430 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20431 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20433 u32
*digest
= (u32
*) hash_buf
->digest
;
20435 salt_t
*salt
= hash_buf
->salt
;
20437 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20443 char *param0_pos
= input_buf
+ 6 + 1;
20445 char *param1_pos
= strchr (param0_pos
, '*');
20447 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20449 u32 param0_len
= param1_pos
- param0_pos
;
20453 char *param2_pos
= strchr (param1_pos
, '*');
20455 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20457 u32 param1_len
= param2_pos
- param1_pos
;
20461 char *param3_pos
= strchr (param2_pos
, '*');
20463 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20465 u32 param2_len
= param3_pos
- param2_pos
;
20469 char *param4_pos
= strchr (param3_pos
, '*');
20471 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20473 u32 param3_len
= param4_pos
- param3_pos
;
20477 char *param5_pos
= strchr (param4_pos
, '*');
20479 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20481 u32 param4_len
= param5_pos
- param4_pos
;
20485 char *param6_pos
= strchr (param5_pos
, '*');
20487 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20489 u32 param5_len
= param6_pos
- param5_pos
;
20493 char *param7_pos
= strchr (param6_pos
, '*');
20495 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20497 u32 param6_len
= param7_pos
- param6_pos
;
20501 char *param8_pos
= strchr (param7_pos
, '*');
20503 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20505 u32 param7_len
= param8_pos
- param7_pos
;
20509 const uint type
= atoi (param0_pos
);
20510 const uint mode
= atoi (param1_pos
);
20511 const uint magic
= atoi (param2_pos
);
20513 char *salt_buf
= param3_pos
;
20515 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20517 const uint compress_length
= atoi (param5_pos
);
20519 char *data_buf
= param6_pos
;
20520 char *auth
= param7_pos
;
20526 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20528 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20530 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20532 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20534 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20536 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20538 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20540 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20542 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20544 if (type
!= 0) return (PARSER_SALT_VALUE
);
20546 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20548 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20550 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20558 zip2
->magic
= magic
;
20562 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20563 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20564 zip2
->salt_buf
[2] = 0;
20565 zip2
->salt_buf
[3] = 0;
20567 zip2
->salt_len
= 8;
20569 else if (mode
== 2)
20571 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20572 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20573 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20574 zip2
->salt_buf
[3] = 0;
20576 zip2
->salt_len
= 12;
20578 else if (mode
== 3)
20580 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20581 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20582 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20583 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20585 zip2
->salt_len
= 16;
20588 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20589 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20590 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20591 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20593 zip2
->verify_bytes
= verify_bytes
;
20595 zip2
->compress_length
= compress_length
;
20597 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20599 for (uint i
= 0; i
< param6_len
; i
+= 2)
20601 const char p0
= data_buf
[i
+ 0];
20602 const char p1
= data_buf
[i
+ 1];
20604 *data_buf_ptr
++ = hex_convert (p1
) << 0
20605 | hex_convert (p0
) << 4;
20610 *data_buf_ptr
= 0x80;
20612 char *auth_ptr
= (char *) zip2
->auth_buf
;
20614 for (uint i
= 0; i
< param7_len
; i
+= 2)
20616 const char p0
= auth
[i
+ 0];
20617 const char p1
= auth
[i
+ 1];
20619 *auth_ptr
++ = hex_convert (p1
) << 0
20620 | hex_convert (p0
) << 4;
20629 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20630 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20631 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20632 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20633 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20634 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20635 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20636 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20638 salt
->salt_len
= 32;
20640 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20643 * digest buf (fake)
20646 digest
[0] = zip2
->auth_buf
[0];
20647 digest
[1] = zip2
->auth_buf
[1];
20648 digest
[2] = zip2
->auth_buf
[2];
20649 digest
[3] = zip2
->auth_buf
[3];
20651 return (PARSER_OK
);
20654 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20656 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20658 u32
*digest
= (u32
*) hash_buf
->digest
;
20660 salt_t
*salt
= hash_buf
->salt
;
20662 win8phone_t
*esalt
= hash_buf
->esalt
;
20664 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20665 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20666 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20667 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20668 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20669 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20670 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20671 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20673 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20675 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20677 u32
*salt_buf
= esalt
->salt_buf
;
20679 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20681 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20684 salt
->salt_buf
[0] = salt_buf
[0];
20685 salt
->salt_buf
[1] = salt_buf
[1];
20686 salt
->salt_buf
[2] = salt_buf
[2];
20687 salt
->salt_buf
[3] = salt_buf
[3];
20688 salt
->salt_buf
[4] = salt_buf
[4];
20689 salt
->salt_buf
[5] = salt_buf
[5];
20690 salt
->salt_buf
[6] = salt_buf
[6];
20691 salt
->salt_buf
[7] = salt_buf
[7];
20693 salt
->salt_len
= 64;
20695 return (PARSER_OK
);
20699 * parallel running threads
20704 BOOL WINAPI
sigHandler_default (DWORD sig
)
20708 case CTRL_CLOSE_EVENT
:
20711 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20712 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20713 * function otherwise it is too late (e.g. after returning from this function)
20718 SetConsoleCtrlHandler (NULL
, TRUE
);
20725 case CTRL_LOGOFF_EVENT
:
20726 case CTRL_SHUTDOWN_EVENT
:
20730 SetConsoleCtrlHandler (NULL
, TRUE
);
20738 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20742 case CTRL_CLOSE_EVENT
:
20746 SetConsoleCtrlHandler (NULL
, TRUE
);
20753 case CTRL_LOGOFF_EVENT
:
20754 case CTRL_SHUTDOWN_EVENT
:
20758 SetConsoleCtrlHandler (NULL
, TRUE
);
20766 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20768 if (callback
== NULL
)
20770 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20774 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20780 void sigHandler_default (int sig
)
20784 signal (sig
, NULL
);
20787 void sigHandler_benchmark (int sig
)
20791 signal (sig
, NULL
);
20794 void hc_signal (void (callback
) (int))
20796 if (callback
== NULL
) callback
= SIG_DFL
;
20798 signal (SIGINT
, callback
);
20799 signal (SIGTERM
, callback
);
20800 signal (SIGABRT
, callback
);
20805 void status_display ();
20807 void *thread_keypress (void *p
)
20809 uint quiet
= data
.quiet
;
20813 while (data
.shutdown_outer
== 0)
20815 int ch
= tty_getchar();
20817 if (ch
== -1) break;
20819 if (ch
== 0) continue;
20821 //https://github.com/hashcat/hashcat/issues/302
20826 hc_thread_mutex_lock (mux_display
);
20842 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20843 if (quiet
== 0) fflush (stdout
);
20855 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20856 if (quiet
== 0) fflush (stdout
);
20868 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20869 if (quiet
== 0) fflush (stdout
);
20881 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20882 if (quiet
== 0) fflush (stdout
);
20890 stop_at_checkpoint ();
20894 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20895 if (quiet
== 0) fflush (stdout
);
20908 //https://github.com/hashcat/hashcat/issues/302
20913 hc_thread_mutex_unlock (mux_display
);
20925 bool class_num (const u8 c
)
20927 return ((c
>= '0') && (c
<= '9'));
20930 bool class_lower (const u8 c
)
20932 return ((c
>= 'a') && (c
<= 'z'));
20935 bool class_upper (const u8 c
)
20937 return ((c
>= 'A') && (c
<= 'Z'));
20940 bool class_alpha (const u8 c
)
20942 return (class_lower (c
) || class_upper (c
));
20945 int conv_ctoi (const u8 c
)
20951 else if (class_upper (c
))
20953 return c
- 'A' + 10;
20959 int conv_itoc (const u8 c
)
20967 return c
+ 'A' - 10;
20977 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20978 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20979 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20980 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20981 #define MAX_KERNEL_RULES 255
20982 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20983 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20984 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20986 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20987 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20988 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20989 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20991 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20996 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20998 switch (rule_buf
[rule_pos
])
21004 case RULE_OP_MANGLE_NOOP
:
21005 SET_NAME (rule
, rule_buf
[rule_pos
]);
21008 case RULE_OP_MANGLE_LREST
:
21009 SET_NAME (rule
, rule_buf
[rule_pos
]);
21012 case RULE_OP_MANGLE_UREST
:
21013 SET_NAME (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_LREST_UFIRST
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21020 case RULE_OP_MANGLE_UREST_LFIRST
:
21021 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 case RULE_OP_MANGLE_TREST
:
21025 SET_NAME (rule
, rule_buf
[rule_pos
]);
21028 case RULE_OP_MANGLE_TOGGLE_AT
:
21029 SET_NAME (rule
, rule_buf
[rule_pos
]);
21030 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_REVERSE
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_DUPEWORD
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21043 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21046 case RULE_OP_MANGLE_REFLECT
:
21047 SET_NAME (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_ROTATE_LEFT
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21054 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21055 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_APPEND
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0 (rule
, rule_buf
[rule_pos
]);
21063 case RULE_OP_MANGLE_PREPEND
:
21064 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 SET_P0 (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_DELETE_FIRST
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21072 case RULE_OP_MANGLE_DELETE_LAST
:
21073 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 case RULE_OP_MANGLE_DELETE_AT
:
21077 SET_NAME (rule
, rule_buf
[rule_pos
]);
21078 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21081 case RULE_OP_MANGLE_EXTRACT
:
21082 SET_NAME (rule
, rule_buf
[rule_pos
]);
21083 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21084 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21087 case RULE_OP_MANGLE_OMIT
:
21088 SET_NAME (rule
, rule_buf
[rule_pos
]);
21089 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21090 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21093 case RULE_OP_MANGLE_INSERT
:
21094 SET_NAME (rule
, rule_buf
[rule_pos
]);
21095 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21096 SET_P1 (rule
, rule_buf
[rule_pos
]);
21099 case RULE_OP_MANGLE_OVERSTRIKE
:
21100 SET_NAME (rule
, rule_buf
[rule_pos
]);
21101 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21102 SET_P1 (rule
, rule_buf
[rule_pos
]);
21105 case RULE_OP_MANGLE_TRUNCATE_AT
:
21106 SET_NAME (rule
, rule_buf
[rule_pos
]);
21107 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21110 case RULE_OP_MANGLE_REPLACE
:
21111 SET_NAME (rule
, rule_buf
[rule_pos
]);
21112 SET_P0 (rule
, rule_buf
[rule_pos
]);
21113 SET_P1 (rule
, rule_buf
[rule_pos
]);
21116 case RULE_OP_MANGLE_PURGECHAR
:
21120 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21124 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21125 SET_NAME (rule
, rule_buf
[rule_pos
]);
21126 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21129 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21130 SET_NAME (rule
, rule_buf
[rule_pos
]);
21131 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21134 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21135 SET_NAME (rule
, rule_buf
[rule_pos
]);
21138 case RULE_OP_MANGLE_SWITCH_FIRST
:
21139 SET_NAME (rule
, rule_buf
[rule_pos
]);
21142 case RULE_OP_MANGLE_SWITCH_LAST
:
21143 SET_NAME (rule
, rule_buf
[rule_pos
]);
21146 case RULE_OP_MANGLE_SWITCH_AT
:
21147 SET_NAME (rule
, rule_buf
[rule_pos
]);
21148 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21149 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21152 case RULE_OP_MANGLE_CHR_SHIFTL
:
21153 SET_NAME (rule
, rule_buf
[rule_pos
]);
21154 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21157 case RULE_OP_MANGLE_CHR_SHIFTR
:
21158 SET_NAME (rule
, rule_buf
[rule_pos
]);
21159 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21162 case RULE_OP_MANGLE_CHR_INCR
:
21163 SET_NAME (rule
, rule_buf
[rule_pos
]);
21164 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21167 case RULE_OP_MANGLE_CHR_DECR
:
21168 SET_NAME (rule
, rule_buf
[rule_pos
]);
21169 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21172 case RULE_OP_MANGLE_REPLACE_NP1
:
21173 SET_NAME (rule
, rule_buf
[rule_pos
]);
21174 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21177 case RULE_OP_MANGLE_REPLACE_NM1
:
21178 SET_NAME (rule
, rule_buf
[rule_pos
]);
21179 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21182 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21183 SET_NAME (rule
, rule_buf
[rule_pos
]);
21184 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21187 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21188 SET_NAME (rule
, rule_buf
[rule_pos
]);
21189 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21192 case RULE_OP_MANGLE_TITLE
:
21193 SET_NAME (rule
, rule_buf
[rule_pos
]);
21202 if (rule_pos
< rule_len
) return (-1);
21207 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21211 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21215 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21219 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21223 case RULE_OP_MANGLE_NOOP
:
21224 rule_buf
[rule_pos
] = rule_cmd
;
21227 case RULE_OP_MANGLE_LREST
:
21228 rule_buf
[rule_pos
] = rule_cmd
;
21231 case RULE_OP_MANGLE_UREST
:
21232 rule_buf
[rule_pos
] = rule_cmd
;
21235 case RULE_OP_MANGLE_LREST_UFIRST
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21239 case RULE_OP_MANGLE_UREST_LFIRST
:
21240 rule_buf
[rule_pos
] = rule_cmd
;
21243 case RULE_OP_MANGLE_TREST
:
21244 rule_buf
[rule_pos
] = rule_cmd
;
21247 case RULE_OP_MANGLE_TOGGLE_AT
:
21248 rule_buf
[rule_pos
] = rule_cmd
;
21249 GET_P0_CONV (rule
);
21252 case RULE_OP_MANGLE_REVERSE
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21256 case RULE_OP_MANGLE_DUPEWORD
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21260 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21262 GET_P0_CONV (rule
);
21265 case RULE_OP_MANGLE_REFLECT
:
21266 rule_buf
[rule_pos
] = rule_cmd
;
21269 case RULE_OP_MANGLE_ROTATE_LEFT
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21273 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21274 rule_buf
[rule_pos
] = rule_cmd
;
21277 case RULE_OP_MANGLE_APPEND
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21282 case RULE_OP_MANGLE_PREPEND
:
21283 rule_buf
[rule_pos
] = rule_cmd
;
21287 case RULE_OP_MANGLE_DELETE_FIRST
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21291 case RULE_OP_MANGLE_DELETE_LAST
:
21292 rule_buf
[rule_pos
] = rule_cmd
;
21295 case RULE_OP_MANGLE_DELETE_AT
:
21296 rule_buf
[rule_pos
] = rule_cmd
;
21297 GET_P0_CONV (rule
);
21300 case RULE_OP_MANGLE_EXTRACT
:
21301 rule_buf
[rule_pos
] = rule_cmd
;
21302 GET_P0_CONV (rule
);
21303 GET_P1_CONV (rule
);
21306 case RULE_OP_MANGLE_OMIT
:
21307 rule_buf
[rule_pos
] = rule_cmd
;
21308 GET_P0_CONV (rule
);
21309 GET_P1_CONV (rule
);
21312 case RULE_OP_MANGLE_INSERT
:
21313 rule_buf
[rule_pos
] = rule_cmd
;
21314 GET_P0_CONV (rule
);
21318 case RULE_OP_MANGLE_OVERSTRIKE
:
21319 rule_buf
[rule_pos
] = rule_cmd
;
21320 GET_P0_CONV (rule
);
21324 case RULE_OP_MANGLE_TRUNCATE_AT
:
21325 rule_buf
[rule_pos
] = rule_cmd
;
21326 GET_P0_CONV (rule
);
21329 case RULE_OP_MANGLE_REPLACE
:
21330 rule_buf
[rule_pos
] = rule_cmd
;
21335 case RULE_OP_MANGLE_PURGECHAR
:
21339 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21343 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21344 rule_buf
[rule_pos
] = rule_cmd
;
21345 GET_P0_CONV (rule
);
21348 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21349 rule_buf
[rule_pos
] = rule_cmd
;
21350 GET_P0_CONV (rule
);
21353 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21354 rule_buf
[rule_pos
] = rule_cmd
;
21357 case RULE_OP_MANGLE_SWITCH_FIRST
:
21358 rule_buf
[rule_pos
] = rule_cmd
;
21361 case RULE_OP_MANGLE_SWITCH_LAST
:
21362 rule_buf
[rule_pos
] = rule_cmd
;
21365 case RULE_OP_MANGLE_SWITCH_AT
:
21366 rule_buf
[rule_pos
] = rule_cmd
;
21367 GET_P0_CONV (rule
);
21368 GET_P1_CONV (rule
);
21371 case RULE_OP_MANGLE_CHR_SHIFTL
:
21372 rule_buf
[rule_pos
] = rule_cmd
;
21373 GET_P0_CONV (rule
);
21376 case RULE_OP_MANGLE_CHR_SHIFTR
:
21377 rule_buf
[rule_pos
] = rule_cmd
;
21378 GET_P0_CONV (rule
);
21381 case RULE_OP_MANGLE_CHR_INCR
:
21382 rule_buf
[rule_pos
] = rule_cmd
;
21383 GET_P0_CONV (rule
);
21386 case RULE_OP_MANGLE_CHR_DECR
:
21387 rule_buf
[rule_pos
] = rule_cmd
;
21388 GET_P0_CONV (rule
);
21391 case RULE_OP_MANGLE_REPLACE_NP1
:
21392 rule_buf
[rule_pos
] = rule_cmd
;
21393 GET_P0_CONV (rule
);
21396 case RULE_OP_MANGLE_REPLACE_NM1
:
21397 rule_buf
[rule_pos
] = rule_cmd
;
21398 GET_P0_CONV (rule
);
21401 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21402 rule_buf
[rule_pos
] = rule_cmd
;
21403 GET_P0_CONV (rule
);
21406 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21407 rule_buf
[rule_pos
] = rule_cmd
;
21408 GET_P0_CONV (rule
);
21411 case RULE_OP_MANGLE_TITLE
:
21412 rule_buf
[rule_pos
] = rule_cmd
;
21416 return rule_pos
- 1;
21434 * CPU rules : this is from hashcat sources, cpu based rules
21437 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21438 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21440 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21441 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21442 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21444 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21445 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21446 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21448 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21452 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21457 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21461 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21466 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21470 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21475 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21480 for (l
= 0; l
< arr_len
; l
++)
21482 r
= arr_len
- 1 - l
;
21486 MANGLE_SWITCH (arr
, l
, r
);
21492 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21494 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21496 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21498 return (arr_len
* 2);
21501 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21503 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21505 int orig_len
= arr_len
;
21509 for (i
= 0; i
< times
; i
++)
21511 memcpy (&arr
[arr_len
], arr
, orig_len
);
21513 arr_len
+= orig_len
;
21519 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21521 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21523 mangle_double (arr
, arr_len
);
21525 mangle_reverse (arr
+ arr_len
, arr_len
);
21527 return (arr_len
* 2);
21530 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21535 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21537 MANGLE_SWITCH (arr
, l
, r
);
21543 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21548 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21550 MANGLE_SWITCH (arr
, l
, r
);
21556 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21558 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21562 return (arr_len
+ 1);
21565 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21567 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21571 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21573 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21578 return (arr_len
+ 1);
21581 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21583 if (upos
>= arr_len
) return (arr_len
);
21587 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21589 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21592 return (arr_len
- 1);
21595 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21597 if (upos
>= arr_len
) return (arr_len
);
21599 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21603 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21605 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21611 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21613 if (upos
>= arr_len
) return (arr_len
);
21615 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21619 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21621 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21624 return (arr_len
- ulen
);
21627 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21629 if (upos
>= arr_len
) return (arr_len
);
21631 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21635 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21637 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21642 return (arr_len
+ 1);
21645 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
)
21647 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21649 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21651 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21653 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21655 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21657 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21659 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21661 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21663 return (arr_len
+ arr2_cpy
);
21666 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21668 if (upos
>= arr_len
) return (arr_len
);
21675 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21677 if (upos
>= arr_len
) return (arr_len
);
21679 memset (arr
+ upos
, 0, arr_len
- upos
);
21684 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21688 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21690 if (arr
[arr_pos
] != oldc
) continue;
21692 arr
[arr_pos
] = newc
;
21698 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21704 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21706 if (arr
[arr_pos
] == c
) continue;
21708 arr
[ret_len
] = arr
[arr_pos
];
21716 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21718 if (ulen
> arr_len
) return (arr_len
);
21720 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21722 char cs
[100] = { 0 };
21724 memcpy (cs
, arr
, ulen
);
21728 for (i
= 0; i
< ulen
; i
++)
21732 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21738 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21740 if (ulen
> arr_len
) return (arr_len
);
21742 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21744 int upos
= arr_len
- ulen
;
21748 for (i
= 0; i
< ulen
; i
++)
21750 char c
= arr
[upos
+ i
];
21752 arr_len
= mangle_append (arr
, arr_len
, c
);
21758 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21760 if ( arr_len
== 0) return (arr_len
);
21761 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21763 char c
= arr
[upos
];
21767 for (i
= 0; i
< ulen
; i
++)
21769 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21775 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21777 if ( arr_len
== 0) return (arr_len
);
21778 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21782 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21784 int new_pos
= arr_pos
* 2;
21786 arr
[new_pos
] = arr
[arr_pos
];
21788 arr
[new_pos
+ 1] = arr
[arr_pos
];
21791 return (arr_len
* 2);
21794 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21796 if (upos
>= arr_len
) return (arr_len
);
21797 if (upos2
>= arr_len
) return (arr_len
);
21799 MANGLE_SWITCH (arr
, upos
, upos2
);
21804 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21806 MANGLE_SWITCH (arr
, upos
, upos2
);
21811 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21813 if (upos
>= arr_len
) return (arr_len
);
21820 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21822 if (upos
>= arr_len
) return (arr_len
);
21829 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21831 if (upos
>= arr_len
) return (arr_len
);
21838 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21840 if (upos
>= arr_len
) return (arr_len
);
21847 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21849 int upper_next
= 1;
21853 for (pos
= 0; pos
< arr_len
; pos
++)
21855 if (arr
[pos
] == ' ')
21866 MANGLE_UPPER_AT (arr
, pos
);
21870 MANGLE_LOWER_AT (arr
, pos
);
21877 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21879 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21885 for (j
= 0; j
< rp_gen_num
; j
++)
21892 switch ((char) get_random_num (0, 9))
21895 r
= get_random_num (0, sizeof (grp_op_nop
));
21896 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21900 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21901 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21902 p1
= get_random_num (0, sizeof (grp_pos
));
21903 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21907 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21908 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21909 p1
= get_random_num (1, 6);
21910 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21914 r
= get_random_num (0, sizeof (grp_op_chr
));
21915 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21916 p1
= get_random_num (0x20, 0x7e);
21917 rule_buf
[rule_pos
++] = (char) p1
;
21921 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21922 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21923 p1
= get_random_num (0x20, 0x7e);
21924 rule_buf
[rule_pos
++] = (char) p1
;
21925 p2
= get_random_num (0x20, 0x7e);
21927 p2
= get_random_num (0x20, 0x7e);
21928 rule_buf
[rule_pos
++] = (char) p2
;
21932 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21933 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21934 p1
= get_random_num (0, sizeof (grp_pos
));
21935 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21936 p2
= get_random_num (0x20, 0x7e);
21937 rule_buf
[rule_pos
++] = (char) p2
;
21941 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21942 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21943 p1
= get_random_num (0, sizeof (grp_pos
));
21944 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21945 p2
= get_random_num (0, sizeof (grp_pos
));
21947 p2
= get_random_num (0, sizeof (grp_pos
));
21948 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21952 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21953 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21954 p1
= get_random_num (0, sizeof (grp_pos
));
21955 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21956 p2
= get_random_num (1, sizeof (grp_pos
));
21958 p2
= get_random_num (1, sizeof (grp_pos
));
21959 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21963 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21964 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21965 p1
= get_random_num (0, sizeof (grp_pos
));
21966 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21967 p2
= get_random_num (1, sizeof (grp_pos
));
21968 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21969 p3
= get_random_num (0, sizeof (grp_pos
));
21970 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21978 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21980 char mem
[BLOCK_SIZE
] = { 0 };
21982 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21984 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21986 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21988 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21990 int out_len
= in_len
;
21991 int mem_len
= in_len
;
21993 memcpy (out
, in
, out_len
);
21997 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
22002 switch (rule
[rule_pos
])
22007 case RULE_OP_MANGLE_NOOP
:
22010 case RULE_OP_MANGLE_LREST
:
22011 out_len
= mangle_lrest (out
, out_len
);
22014 case RULE_OP_MANGLE_UREST
:
22015 out_len
= mangle_urest (out
, out_len
);
22018 case RULE_OP_MANGLE_LREST_UFIRST
:
22019 out_len
= mangle_lrest (out
, out_len
);
22020 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22023 case RULE_OP_MANGLE_UREST_LFIRST
:
22024 out_len
= mangle_urest (out
, out_len
);
22025 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22028 case RULE_OP_MANGLE_TREST
:
22029 out_len
= mangle_trest (out
, out_len
);
22032 case RULE_OP_MANGLE_TOGGLE_AT
:
22033 NEXT_RULEPOS (rule_pos
);
22034 NEXT_RPTOI (rule
, rule_pos
, upos
);
22035 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22038 case RULE_OP_MANGLE_REVERSE
:
22039 out_len
= mangle_reverse (out
, out_len
);
22042 case RULE_OP_MANGLE_DUPEWORD
:
22043 out_len
= mangle_double (out
, out_len
);
22046 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22047 NEXT_RULEPOS (rule_pos
);
22048 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22049 out_len
= mangle_double_times (out
, out_len
, ulen
);
22052 case RULE_OP_MANGLE_REFLECT
:
22053 out_len
= mangle_reflect (out
, out_len
);
22056 case RULE_OP_MANGLE_ROTATE_LEFT
:
22057 mangle_rotate_left (out
, out_len
);
22060 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22061 mangle_rotate_right (out
, out_len
);
22064 case RULE_OP_MANGLE_APPEND
:
22065 NEXT_RULEPOS (rule_pos
);
22066 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22069 case RULE_OP_MANGLE_PREPEND
:
22070 NEXT_RULEPOS (rule_pos
);
22071 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22074 case RULE_OP_MANGLE_DELETE_FIRST
:
22075 out_len
= mangle_delete_at (out
, out_len
, 0);
22078 case RULE_OP_MANGLE_DELETE_LAST
:
22079 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22082 case RULE_OP_MANGLE_DELETE_AT
:
22083 NEXT_RULEPOS (rule_pos
);
22084 NEXT_RPTOI (rule
, rule_pos
, upos
);
22085 out_len
= mangle_delete_at (out
, out_len
, upos
);
22088 case RULE_OP_MANGLE_EXTRACT
:
22089 NEXT_RULEPOS (rule_pos
);
22090 NEXT_RPTOI (rule
, rule_pos
, upos
);
22091 NEXT_RULEPOS (rule_pos
);
22092 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22093 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22096 case RULE_OP_MANGLE_OMIT
:
22097 NEXT_RULEPOS (rule_pos
);
22098 NEXT_RPTOI (rule
, rule_pos
, upos
);
22099 NEXT_RULEPOS (rule_pos
);
22100 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22101 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22104 case RULE_OP_MANGLE_INSERT
:
22105 NEXT_RULEPOS (rule_pos
);
22106 NEXT_RPTOI (rule
, rule_pos
, upos
);
22107 NEXT_RULEPOS (rule_pos
);
22108 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22111 case RULE_OP_MANGLE_OVERSTRIKE
:
22112 NEXT_RULEPOS (rule_pos
);
22113 NEXT_RPTOI (rule
, rule_pos
, upos
);
22114 NEXT_RULEPOS (rule_pos
);
22115 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22118 case RULE_OP_MANGLE_TRUNCATE_AT
:
22119 NEXT_RULEPOS (rule_pos
);
22120 NEXT_RPTOI (rule
, rule_pos
, upos
);
22121 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22124 case RULE_OP_MANGLE_REPLACE
:
22125 NEXT_RULEPOS (rule_pos
);
22126 NEXT_RULEPOS (rule_pos
);
22127 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22130 case RULE_OP_MANGLE_PURGECHAR
:
22131 NEXT_RULEPOS (rule_pos
);
22132 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22135 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22139 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22140 NEXT_RULEPOS (rule_pos
);
22141 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22142 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22145 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22146 NEXT_RULEPOS (rule_pos
);
22147 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22148 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22151 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22152 out_len
= mangle_dupechar (out
, out_len
);
22155 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22156 NEXT_RULEPOS (rule_pos
);
22157 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22158 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22161 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22162 NEXT_RULEPOS (rule_pos
);
22163 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22164 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22167 case RULE_OP_MANGLE_SWITCH_FIRST
:
22168 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22171 case RULE_OP_MANGLE_SWITCH_LAST
:
22172 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22175 case RULE_OP_MANGLE_SWITCH_AT
:
22176 NEXT_RULEPOS (rule_pos
);
22177 NEXT_RPTOI (rule
, rule_pos
, upos
);
22178 NEXT_RULEPOS (rule_pos
);
22179 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22180 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22183 case RULE_OP_MANGLE_CHR_SHIFTL
:
22184 NEXT_RULEPOS (rule_pos
);
22185 NEXT_RPTOI (rule
, rule_pos
, upos
);
22186 mangle_chr_shiftl (out
, out_len
, upos
);
22189 case RULE_OP_MANGLE_CHR_SHIFTR
:
22190 NEXT_RULEPOS (rule_pos
);
22191 NEXT_RPTOI (rule
, rule_pos
, upos
);
22192 mangle_chr_shiftr (out
, out_len
, upos
);
22195 case RULE_OP_MANGLE_CHR_INCR
:
22196 NEXT_RULEPOS (rule_pos
);
22197 NEXT_RPTOI (rule
, rule_pos
, upos
);
22198 mangle_chr_incr (out
, out_len
, upos
);
22201 case RULE_OP_MANGLE_CHR_DECR
:
22202 NEXT_RULEPOS (rule_pos
);
22203 NEXT_RPTOI (rule
, rule_pos
, upos
);
22204 mangle_chr_decr (out
, out_len
, upos
);
22207 case RULE_OP_MANGLE_REPLACE_NP1
:
22208 NEXT_RULEPOS (rule_pos
);
22209 NEXT_RPTOI (rule
, rule_pos
, upos
);
22210 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22213 case RULE_OP_MANGLE_REPLACE_NM1
:
22214 NEXT_RULEPOS (rule_pos
);
22215 NEXT_RPTOI (rule
, rule_pos
, upos
);
22216 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22219 case RULE_OP_MANGLE_TITLE
:
22220 out_len
= mangle_title (out
, out_len
);
22223 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22224 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22225 NEXT_RULEPOS (rule_pos
);
22226 NEXT_RPTOI (rule
, rule_pos
, upos
);
22227 NEXT_RULEPOS (rule_pos
);
22228 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22229 NEXT_RULEPOS (rule_pos
);
22230 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22231 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22234 case RULE_OP_MANGLE_APPEND_MEMORY
:
22235 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22236 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22237 memcpy (out
+ out_len
, mem
, mem_len
);
22238 out_len
+= mem_len
;
22241 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22242 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22243 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22244 memcpy (mem
+ mem_len
, out
, out_len
);
22245 out_len
+= mem_len
;
22246 memcpy (out
, mem
, out_len
);
22249 case RULE_OP_MEMORIZE_WORD
:
22250 memcpy (mem
, out
, out_len
);
22254 case RULE_OP_REJECT_LESS
:
22255 NEXT_RULEPOS (rule_pos
);
22256 NEXT_RPTOI (rule
, rule_pos
, upos
);
22257 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22260 case RULE_OP_REJECT_GREATER
:
22261 NEXT_RULEPOS (rule_pos
);
22262 NEXT_RPTOI (rule
, rule_pos
, upos
);
22263 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22266 case RULE_OP_REJECT_CONTAIN
:
22267 NEXT_RULEPOS (rule_pos
);
22268 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22271 case RULE_OP_REJECT_NOT_CONTAIN
:
22272 NEXT_RULEPOS (rule_pos
);
22273 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22276 case RULE_OP_REJECT_EQUAL_FIRST
:
22277 NEXT_RULEPOS (rule_pos
);
22278 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22281 case RULE_OP_REJECT_EQUAL_LAST
:
22282 NEXT_RULEPOS (rule_pos
);
22283 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22286 case RULE_OP_REJECT_EQUAL_AT
:
22287 NEXT_RULEPOS (rule_pos
);
22288 NEXT_RPTOI (rule
, rule_pos
, upos
);
22289 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22290 NEXT_RULEPOS (rule_pos
);
22291 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22294 case RULE_OP_REJECT_CONTAINS
:
22295 NEXT_RULEPOS (rule_pos
);
22296 NEXT_RPTOI (rule
, rule_pos
, upos
);
22297 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22298 NEXT_RULEPOS (rule_pos
);
22299 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22300 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22303 case RULE_OP_REJECT_MEMORY
:
22304 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22308 return (RULE_RC_SYNTAX_ERROR
);
22313 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);