2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
117 int log_out_nn (FILE *fp
, const char *fmt
, ...)
119 if (SUPPRESS_OUTPUT
) return 0;
125 const int len
= log_final (fp
, fmt
, ap
);
132 int log_info_nn (const char *fmt
, ...)
134 if (SUPPRESS_OUTPUT
) return 0;
140 const int len
= log_final (stdout
, fmt
, ap
);
147 int log_error_nn (const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return 0;
155 const int len
= log_final (stderr
, fmt
, ap
);
162 int log_out (FILE *fp
, const char *fmt
, ...)
164 if (SUPPRESS_OUTPUT
) return 0;
170 const int len
= log_final (fp
, fmt
, ap
);
181 int log_info (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return 0;
189 const int len
= log_final (stdout
, fmt
, ap
);
193 fputc ('\n', stdout
);
200 int log_error (const char *fmt
, ...)
202 if (SUPPRESS_OUTPUT
) return 0;
204 fputc ('\n', stderr
);
205 fputc ('\n', stderr
);
211 const int len
= log_final (stderr
, fmt
, ap
);
215 fputc ('\n', stderr
);
216 fputc ('\n', stderr
);
227 u8
int_to_base32 (const u8 c
)
229 static const u8 tbl
[0x20] =
231 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
232 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
238 u8
base32_to_int (const u8 c
)
240 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
241 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
246 u8
int_to_itoa32 (const u8 c
)
248 static const u8 tbl
[0x20] =
250 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
251 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
257 u8
itoa32_to_int (const u8 c
)
259 if ((c
>= '0') && (c
<= '9')) return c
- '0';
260 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
265 u8
int_to_itoa64 (const u8 c
)
267 static const u8 tbl
[0x40] =
269 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
270 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
271 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
272 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
278 u8
itoa64_to_int (const u8 c
)
280 static const u8 tbl
[0x100] =
282 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
283 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
284 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
285 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
286 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
287 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
288 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
289 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
290 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
291 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
292 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
293 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
294 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
295 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
296 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
297 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
303 u8
int_to_base64 (const u8 c
)
305 static const u8 tbl
[0x40] =
307 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
308 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
309 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
310 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
316 u8
base64_to_int (const u8 c
)
318 static const u8 tbl
[0x100] =
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
323 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
327 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 u8
int_to_bf64 (const u8 c
)
343 static const u8 tbl
[0x40] =
345 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
346 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
347 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
348 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
354 u8
bf64_to_int (const u8 c
)
356 static const u8 tbl
[0x100] =
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
361 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
363 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
365 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 u8
int_to_lotus64 (const u8 c
)
381 if (c
< 10) return '0' + c
;
382 else if (c
< 36) return 'A' + c
- 10;
383 else if (c
< 62) return 'a' + c
- 36;
384 else if (c
== 62) return '+';
385 else if (c
== 63) return '/';
390 u8
lotus64_to_int (const u8 c
)
392 if ((c
>= '0') && (c
<= '9')) return c
- '0';
393 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
394 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
395 else if (c
== '+') return 62;
396 else if (c
== '/') return 63;
402 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
404 const u8
*in_ptr
= in_buf
;
406 u8
*out_ptr
= out_buf
;
408 for (int i
= 0; i
< in_len
; i
+= 8)
410 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
411 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
412 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
413 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
414 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
415 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
416 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
417 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
419 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
420 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
421 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
422 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
423 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
429 for (int i
= 0; i
< in_len
; i
++)
431 if (in_buf
[i
] != '=') continue;
436 int out_len
= (in_len
* 5) / 8;
441 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
443 const u8
*in_ptr
= in_buf
;
445 u8
*out_ptr
= out_buf
;
447 for (int i
= 0; i
< in_len
; i
+= 5)
449 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
450 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
451 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
452 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
453 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
454 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
455 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
456 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
458 out_ptr
[0] = out_val0
& 0x7f;
459 out_ptr
[1] = out_val1
& 0x7f;
460 out_ptr
[2] = out_val2
& 0x7f;
461 out_ptr
[3] = out_val3
& 0x7f;
462 out_ptr
[4] = out_val4
& 0x7f;
463 out_ptr
[5] = out_val5
& 0x7f;
464 out_ptr
[6] = out_val6
& 0x7f;
465 out_ptr
[7] = out_val7
& 0x7f;
471 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
475 out_buf
[out_len
] = '=';
483 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
485 const u8
*in_ptr
= in_buf
;
487 u8
*out_ptr
= out_buf
;
489 for (int i
= 0; i
< in_len
; i
+= 4)
491 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
492 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
493 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
494 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
496 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
497 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
498 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
504 for (int i
= 0; i
< in_len
; i
++)
506 if (in_buf
[i
] != '=') continue;
511 int out_len
= (in_len
* 6) / 8;
516 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
518 const u8
*in_ptr
= in_buf
;
520 u8
*out_ptr
= out_buf
;
522 for (int i
= 0; i
< in_len
; i
+= 3)
524 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
525 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
526 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
527 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
529 out_ptr
[0] = out_val0
& 0x7f;
530 out_ptr
[1] = out_val1
& 0x7f;
531 out_ptr
[2] = out_val2
& 0x7f;
532 out_ptr
[3] = out_val3
& 0x7f;
538 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
542 out_buf
[out_len
] = '=';
550 int is_valid_hex_char (const u8 c
)
552 if ((c
>= '0') && (c
<= '9')) return 1;
553 if ((c
>= 'A') && (c
<= 'F')) return 1;
554 if ((c
>= 'a') && (c
<= 'f')) return 1;
559 u8
hex_convert (const u8 c
)
561 return (c
& 15) + (c
>> 6) * 9;
564 u8
hex_to_u8 (const u8 hex
[2])
568 v
|= (hex_convert (hex
[1]) << 0);
569 v
|= (hex_convert (hex
[0]) << 4);
574 u32
hex_to_u32 (const u8 hex
[8])
578 v
|= ((u32
) hex_convert (hex
[7])) << 0;
579 v
|= ((u32
) hex_convert (hex
[6])) << 4;
580 v
|= ((u32
) hex_convert (hex
[5])) << 8;
581 v
|= ((u32
) hex_convert (hex
[4])) << 12;
582 v
|= ((u32
) hex_convert (hex
[3])) << 16;
583 v
|= ((u32
) hex_convert (hex
[2])) << 20;
584 v
|= ((u32
) hex_convert (hex
[1])) << 24;
585 v
|= ((u32
) hex_convert (hex
[0])) << 28;
590 u64
hex_to_u64 (const u8 hex
[16])
594 v
|= ((u64
) hex_convert (hex
[15]) << 0);
595 v
|= ((u64
) hex_convert (hex
[14]) << 4);
596 v
|= ((u64
) hex_convert (hex
[13]) << 8);
597 v
|= ((u64
) hex_convert (hex
[12]) << 12);
598 v
|= ((u64
) hex_convert (hex
[11]) << 16);
599 v
|= ((u64
) hex_convert (hex
[10]) << 20);
600 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
601 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
602 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
603 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
604 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
605 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
606 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
607 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
608 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
609 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
614 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
616 hex
[0] = v
>> 28 & 15;
617 hex
[1] = v
>> 24 & 15;
618 hex
[2] = v
>> 20 & 15;
619 hex
[3] = v
>> 16 & 15;
620 hex
[4] = v
>> 12 & 15;
621 hex
[5] = v
>> 8 & 15;
622 hex
[6] = v
>> 4 & 15;
623 hex
[7] = v
>> 0 & 15;
627 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
628 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
629 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
630 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
631 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
632 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
633 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
634 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
641 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
645 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
654 for (int i
= 0; i
< 16; i
+= 4)
664 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
671 out
[i
+ 0] = _out
[0];
672 out
[i
+ 1] = _out
[1];
673 out
[i
+ 2] = _out
[2];
674 out
[i
+ 3] = _out
[3];
683 static void juniper_decrypt_hash (char *in
, char *out
)
687 u8 base64_buf
[100] = { 0 };
689 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
693 u32 juniper_iv
[4] = { 0 };
695 memcpy (juniper_iv
, base64_buf
, 12);
697 memcpy (out
, juniper_iv
, 12);
701 u32 juniper_key
[4] = { 0 };
703 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
704 juniper_key
[1] = byte_swap_32 (0x8df91059);
705 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
706 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
710 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
711 u32
*out_ptr
= (u32
*) (out
+ 12);
713 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
716 void phpass_decode (u8 digest
[16], u8 buf
[22])
720 l
= itoa64_to_int (buf
[ 0]) << 0;
721 l
|= itoa64_to_int (buf
[ 1]) << 6;
722 l
|= itoa64_to_int (buf
[ 2]) << 12;
723 l
|= itoa64_to_int (buf
[ 3]) << 18;
725 digest
[ 0] = (l
>> 0) & 0xff;
726 digest
[ 1] = (l
>> 8) & 0xff;
727 digest
[ 2] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[ 4]) << 0;
730 l
|= itoa64_to_int (buf
[ 5]) << 6;
731 l
|= itoa64_to_int (buf
[ 6]) << 12;
732 l
|= itoa64_to_int (buf
[ 7]) << 18;
734 digest
[ 3] = (l
>> 0) & 0xff;
735 digest
[ 4] = (l
>> 8) & 0xff;
736 digest
[ 5] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[ 8]) << 0;
739 l
|= itoa64_to_int (buf
[ 9]) << 6;
740 l
|= itoa64_to_int (buf
[10]) << 12;
741 l
|= itoa64_to_int (buf
[11]) << 18;
743 digest
[ 6] = (l
>> 0) & 0xff;
744 digest
[ 7] = (l
>> 8) & 0xff;
745 digest
[ 8] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[12]) << 0;
748 l
|= itoa64_to_int (buf
[13]) << 6;
749 l
|= itoa64_to_int (buf
[14]) << 12;
750 l
|= itoa64_to_int (buf
[15]) << 18;
752 digest
[ 9] = (l
>> 0) & 0xff;
753 digest
[10] = (l
>> 8) & 0xff;
754 digest
[11] = (l
>> 16) & 0xff;
756 l
= itoa64_to_int (buf
[16]) << 0;
757 l
|= itoa64_to_int (buf
[17]) << 6;
758 l
|= itoa64_to_int (buf
[18]) << 12;
759 l
|= itoa64_to_int (buf
[19]) << 18;
761 digest
[12] = (l
>> 0) & 0xff;
762 digest
[13] = (l
>> 8) & 0xff;
763 digest
[14] = (l
>> 16) & 0xff;
765 l
= itoa64_to_int (buf
[20]) << 0;
766 l
|= itoa64_to_int (buf
[21]) << 6;
768 digest
[15] = (l
>> 0) & 0xff;
771 void phpass_encode (u8 digest
[16], u8 buf
[22])
775 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
777 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
784 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
791 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[11] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
798 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
800 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[15] = int_to_itoa64 (l
& 0x3f);
803 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
805 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
807 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
808 buf
[19] = int_to_itoa64 (l
& 0x3f);
810 l
= (digest
[15] << 0);
812 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[21] = int_to_itoa64 (l
& 0x3f);
816 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
820 l
= itoa64_to_int (buf
[ 0]) << 0;
821 l
|= itoa64_to_int (buf
[ 1]) << 6;
822 l
|= itoa64_to_int (buf
[ 2]) << 12;
823 l
|= itoa64_to_int (buf
[ 3]) << 18;
825 digest
[ 0] = (l
>> 16) & 0xff;
826 digest
[ 6] = (l
>> 8) & 0xff;
827 digest
[12] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[ 4]) << 0;
830 l
|= itoa64_to_int (buf
[ 5]) << 6;
831 l
|= itoa64_to_int (buf
[ 6]) << 12;
832 l
|= itoa64_to_int (buf
[ 7]) << 18;
834 digest
[ 1] = (l
>> 16) & 0xff;
835 digest
[ 7] = (l
>> 8) & 0xff;
836 digest
[13] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[ 8]) << 0;
839 l
|= itoa64_to_int (buf
[ 9]) << 6;
840 l
|= itoa64_to_int (buf
[10]) << 12;
841 l
|= itoa64_to_int (buf
[11]) << 18;
843 digest
[ 2] = (l
>> 16) & 0xff;
844 digest
[ 8] = (l
>> 8) & 0xff;
845 digest
[14] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[12]) << 0;
848 l
|= itoa64_to_int (buf
[13]) << 6;
849 l
|= itoa64_to_int (buf
[14]) << 12;
850 l
|= itoa64_to_int (buf
[15]) << 18;
852 digest
[ 3] = (l
>> 16) & 0xff;
853 digest
[ 9] = (l
>> 8) & 0xff;
854 digest
[15] = (l
>> 0) & 0xff;
856 l
= itoa64_to_int (buf
[16]) << 0;
857 l
|= itoa64_to_int (buf
[17]) << 6;
858 l
|= itoa64_to_int (buf
[18]) << 12;
859 l
|= itoa64_to_int (buf
[19]) << 18;
861 digest
[ 4] = (l
>> 16) & 0xff;
862 digest
[10] = (l
>> 8) & 0xff;
863 digest
[ 5] = (l
>> 0) & 0xff;
865 l
= itoa64_to_int (buf
[20]) << 0;
866 l
|= itoa64_to_int (buf
[21]) << 6;
868 digest
[11] = (l
>> 0) & 0xff;
871 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
875 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
877 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
884 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
891 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
898 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
900 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
903 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
905 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
907 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
910 l
= (digest
[11] << 0);
912 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
916 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
920 l
= itoa64_to_int (buf
[ 0]) << 0;
921 l
|= itoa64_to_int (buf
[ 1]) << 6;
922 l
|= itoa64_to_int (buf
[ 2]) << 12;
923 l
|= itoa64_to_int (buf
[ 3]) << 18;
925 digest
[ 0] = (l
>> 16) & 0xff;
926 digest
[21] = (l
>> 8) & 0xff;
927 digest
[42] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[ 4]) << 0;
930 l
|= itoa64_to_int (buf
[ 5]) << 6;
931 l
|= itoa64_to_int (buf
[ 6]) << 12;
932 l
|= itoa64_to_int (buf
[ 7]) << 18;
934 digest
[22] = (l
>> 16) & 0xff;
935 digest
[43] = (l
>> 8) & 0xff;
936 digest
[ 1] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[ 8]) << 0;
939 l
|= itoa64_to_int (buf
[ 9]) << 6;
940 l
|= itoa64_to_int (buf
[10]) << 12;
941 l
|= itoa64_to_int (buf
[11]) << 18;
943 digest
[44] = (l
>> 16) & 0xff;
944 digest
[ 2] = (l
>> 8) & 0xff;
945 digest
[23] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[12]) << 0;
948 l
|= itoa64_to_int (buf
[13]) << 6;
949 l
|= itoa64_to_int (buf
[14]) << 12;
950 l
|= itoa64_to_int (buf
[15]) << 18;
952 digest
[ 3] = (l
>> 16) & 0xff;
953 digest
[24] = (l
>> 8) & 0xff;
954 digest
[45] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[16]) << 0;
957 l
|= itoa64_to_int (buf
[17]) << 6;
958 l
|= itoa64_to_int (buf
[18]) << 12;
959 l
|= itoa64_to_int (buf
[19]) << 18;
961 digest
[25] = (l
>> 16) & 0xff;
962 digest
[46] = (l
>> 8) & 0xff;
963 digest
[ 4] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[20]) << 0;
966 l
|= itoa64_to_int (buf
[21]) << 6;
967 l
|= itoa64_to_int (buf
[22]) << 12;
968 l
|= itoa64_to_int (buf
[23]) << 18;
970 digest
[47] = (l
>> 16) & 0xff;
971 digest
[ 5] = (l
>> 8) & 0xff;
972 digest
[26] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[24]) << 0;
975 l
|= itoa64_to_int (buf
[25]) << 6;
976 l
|= itoa64_to_int (buf
[26]) << 12;
977 l
|= itoa64_to_int (buf
[27]) << 18;
979 digest
[ 6] = (l
>> 16) & 0xff;
980 digest
[27] = (l
>> 8) & 0xff;
981 digest
[48] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[28]) << 0;
984 l
|= itoa64_to_int (buf
[29]) << 6;
985 l
|= itoa64_to_int (buf
[30]) << 12;
986 l
|= itoa64_to_int (buf
[31]) << 18;
988 digest
[28] = (l
>> 16) & 0xff;
989 digest
[49] = (l
>> 8) & 0xff;
990 digest
[ 7] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[32]) << 0;
993 l
|= itoa64_to_int (buf
[33]) << 6;
994 l
|= itoa64_to_int (buf
[34]) << 12;
995 l
|= itoa64_to_int (buf
[35]) << 18;
997 digest
[50] = (l
>> 16) & 0xff;
998 digest
[ 8] = (l
>> 8) & 0xff;
999 digest
[29] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[36]) << 0;
1002 l
|= itoa64_to_int (buf
[37]) << 6;
1003 l
|= itoa64_to_int (buf
[38]) << 12;
1004 l
|= itoa64_to_int (buf
[39]) << 18;
1006 digest
[ 9] = (l
>> 16) & 0xff;
1007 digest
[30] = (l
>> 8) & 0xff;
1008 digest
[51] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[40]) << 0;
1011 l
|= itoa64_to_int (buf
[41]) << 6;
1012 l
|= itoa64_to_int (buf
[42]) << 12;
1013 l
|= itoa64_to_int (buf
[43]) << 18;
1015 digest
[31] = (l
>> 16) & 0xff;
1016 digest
[52] = (l
>> 8) & 0xff;
1017 digest
[10] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[44]) << 0;
1020 l
|= itoa64_to_int (buf
[45]) << 6;
1021 l
|= itoa64_to_int (buf
[46]) << 12;
1022 l
|= itoa64_to_int (buf
[47]) << 18;
1024 digest
[53] = (l
>> 16) & 0xff;
1025 digest
[11] = (l
>> 8) & 0xff;
1026 digest
[32] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[48]) << 0;
1029 l
|= itoa64_to_int (buf
[49]) << 6;
1030 l
|= itoa64_to_int (buf
[50]) << 12;
1031 l
|= itoa64_to_int (buf
[51]) << 18;
1033 digest
[12] = (l
>> 16) & 0xff;
1034 digest
[33] = (l
>> 8) & 0xff;
1035 digest
[54] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[52]) << 0;
1038 l
|= itoa64_to_int (buf
[53]) << 6;
1039 l
|= itoa64_to_int (buf
[54]) << 12;
1040 l
|= itoa64_to_int (buf
[55]) << 18;
1042 digest
[34] = (l
>> 16) & 0xff;
1043 digest
[55] = (l
>> 8) & 0xff;
1044 digest
[13] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[56]) << 0;
1047 l
|= itoa64_to_int (buf
[57]) << 6;
1048 l
|= itoa64_to_int (buf
[58]) << 12;
1049 l
|= itoa64_to_int (buf
[59]) << 18;
1051 digest
[56] = (l
>> 16) & 0xff;
1052 digest
[14] = (l
>> 8) & 0xff;
1053 digest
[35] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[60]) << 0;
1056 l
|= itoa64_to_int (buf
[61]) << 6;
1057 l
|= itoa64_to_int (buf
[62]) << 12;
1058 l
|= itoa64_to_int (buf
[63]) << 18;
1060 digest
[15] = (l
>> 16) & 0xff;
1061 digest
[36] = (l
>> 8) & 0xff;
1062 digest
[57] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[64]) << 0;
1065 l
|= itoa64_to_int (buf
[65]) << 6;
1066 l
|= itoa64_to_int (buf
[66]) << 12;
1067 l
|= itoa64_to_int (buf
[67]) << 18;
1069 digest
[37] = (l
>> 16) & 0xff;
1070 digest
[58] = (l
>> 8) & 0xff;
1071 digest
[16] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[68]) << 0;
1074 l
|= itoa64_to_int (buf
[69]) << 6;
1075 l
|= itoa64_to_int (buf
[70]) << 12;
1076 l
|= itoa64_to_int (buf
[71]) << 18;
1078 digest
[59] = (l
>> 16) & 0xff;
1079 digest
[17] = (l
>> 8) & 0xff;
1080 digest
[38] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[72]) << 0;
1083 l
|= itoa64_to_int (buf
[73]) << 6;
1084 l
|= itoa64_to_int (buf
[74]) << 12;
1085 l
|= itoa64_to_int (buf
[75]) << 18;
1087 digest
[18] = (l
>> 16) & 0xff;
1088 digest
[39] = (l
>> 8) & 0xff;
1089 digest
[60] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[76]) << 0;
1092 l
|= itoa64_to_int (buf
[77]) << 6;
1093 l
|= itoa64_to_int (buf
[78]) << 12;
1094 l
|= itoa64_to_int (buf
[79]) << 18;
1096 digest
[40] = (l
>> 16) & 0xff;
1097 digest
[61] = (l
>> 8) & 0xff;
1098 digest
[19] = (l
>> 0) & 0xff;
1100 l
= itoa64_to_int (buf
[80]) << 0;
1101 l
|= itoa64_to_int (buf
[81]) << 6;
1102 l
|= itoa64_to_int (buf
[82]) << 12;
1103 l
|= itoa64_to_int (buf
[83]) << 18;
1105 digest
[62] = (l
>> 16) & 0xff;
1106 digest
[20] = (l
>> 8) & 0xff;
1107 digest
[41] = (l
>> 0) & 0xff;
1109 l
= itoa64_to_int (buf
[84]) << 0;
1110 l
|= itoa64_to_int (buf
[85]) << 6;
1112 digest
[63] = (l
>> 0) & 0xff;
1115 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1119 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1121 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1128 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1135 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1142 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1149 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1156 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1163 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1170 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1177 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1184 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1191 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1198 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1205 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1212 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1219 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1226 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1233 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1240 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1247 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1254 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1256 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1259 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1261 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1263 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1266 l
= 0 | 0 | (digest
[63] << 0);
1268 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1272 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1276 l
= itoa64_to_int (buf
[ 0]) << 0;
1277 l
|= itoa64_to_int (buf
[ 1]) << 6;
1278 l
|= itoa64_to_int (buf
[ 2]) << 12;
1279 l
|= itoa64_to_int (buf
[ 3]) << 18;
1281 digest
[ 2] = (l
>> 0) & 0xff;
1282 digest
[ 1] = (l
>> 8) & 0xff;
1283 digest
[ 0] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[ 4]) << 0;
1286 l
|= itoa64_to_int (buf
[ 5]) << 6;
1287 l
|= itoa64_to_int (buf
[ 6]) << 12;
1288 l
|= itoa64_to_int (buf
[ 7]) << 18;
1290 digest
[ 5] = (l
>> 0) & 0xff;
1291 digest
[ 4] = (l
>> 8) & 0xff;
1292 digest
[ 3] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[ 8]) << 0;
1295 l
|= itoa64_to_int (buf
[ 9]) << 6;
1296 l
|= itoa64_to_int (buf
[10]) << 12;
1297 l
|= itoa64_to_int (buf
[11]) << 18;
1299 digest
[ 8] = (l
>> 0) & 0xff;
1300 digest
[ 7] = (l
>> 8) & 0xff;
1301 digest
[ 6] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[12]) << 0;
1304 l
|= itoa64_to_int (buf
[13]) << 6;
1305 l
|= itoa64_to_int (buf
[14]) << 12;
1306 l
|= itoa64_to_int (buf
[15]) << 18;
1308 digest
[11] = (l
>> 0) & 0xff;
1309 digest
[10] = (l
>> 8) & 0xff;
1310 digest
[ 9] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[16]) << 0;
1313 l
|= itoa64_to_int (buf
[17]) << 6;
1314 l
|= itoa64_to_int (buf
[18]) << 12;
1315 l
|= itoa64_to_int (buf
[19]) << 18;
1317 digest
[14] = (l
>> 0) & 0xff;
1318 digest
[13] = (l
>> 8) & 0xff;
1319 digest
[12] = (l
>> 16) & 0xff;
1321 l
= itoa64_to_int (buf
[20]) << 0;
1322 l
|= itoa64_to_int (buf
[21]) << 6;
1323 l
|= itoa64_to_int (buf
[22]) << 12;
1324 l
|= itoa64_to_int (buf
[23]) << 18;
1326 digest
[17] = (l
>> 0) & 0xff;
1327 digest
[16] = (l
>> 8) & 0xff;
1328 digest
[15] = (l
>> 16) & 0xff;
1330 l
= itoa64_to_int (buf
[24]) << 0;
1331 l
|= itoa64_to_int (buf
[25]) << 6;
1332 l
|= itoa64_to_int (buf
[26]) << 12;
1334 digest
[19] = (l
>> 8) & 0xff;
1335 digest
[18] = (l
>> 16) & 0xff;
1338 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1342 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1344 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1351 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1358 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[11] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1365 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[15] = int_to_itoa64 (l
& 0x3f);
1370 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1372 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[19] = int_to_itoa64 (l
& 0x3f);
1377 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1379 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1381 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1382 buf
[23] = int_to_itoa64 (l
& 0x3f);
1384 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1386 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1388 buf
[26] = int_to_itoa64 (l
& 0x3f);
1391 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1395 l
= itoa64_to_int (buf
[ 0]) << 0;
1396 l
|= itoa64_to_int (buf
[ 1]) << 6;
1397 l
|= itoa64_to_int (buf
[ 2]) << 12;
1398 l
|= itoa64_to_int (buf
[ 3]) << 18;
1400 digest
[ 2] = (l
>> 0) & 0xff;
1401 digest
[ 1] = (l
>> 8) & 0xff;
1402 digest
[ 0] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[ 4]) << 0;
1405 l
|= itoa64_to_int (buf
[ 5]) << 6;
1406 l
|= itoa64_to_int (buf
[ 6]) << 12;
1407 l
|= itoa64_to_int (buf
[ 7]) << 18;
1409 digest
[ 5] = (l
>> 0) & 0xff;
1410 digest
[ 4] = (l
>> 8) & 0xff;
1411 digest
[ 3] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[ 8]) << 0;
1414 l
|= itoa64_to_int (buf
[ 9]) << 6;
1415 l
|= itoa64_to_int (buf
[10]) << 12;
1416 l
|= itoa64_to_int (buf
[11]) << 18;
1418 digest
[ 8] = (l
>> 0) & 0xff;
1419 digest
[ 7] = (l
>> 8) & 0xff;
1420 digest
[ 6] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[12]) << 0;
1423 l
|= itoa64_to_int (buf
[13]) << 6;
1424 l
|= itoa64_to_int (buf
[14]) << 12;
1425 l
|= itoa64_to_int (buf
[15]) << 18;
1427 digest
[11] = (l
>> 0) & 0xff;
1428 digest
[10] = (l
>> 8) & 0xff;
1429 digest
[ 9] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[16]) << 0;
1432 l
|= itoa64_to_int (buf
[17]) << 6;
1433 l
|= itoa64_to_int (buf
[18]) << 12;
1434 l
|= itoa64_to_int (buf
[19]) << 18;
1436 digest
[14] = (l
>> 0) & 0xff;
1437 digest
[13] = (l
>> 8) & 0xff;
1438 digest
[12] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[20]) << 0;
1441 l
|= itoa64_to_int (buf
[21]) << 6;
1442 l
|= itoa64_to_int (buf
[22]) << 12;
1443 l
|= itoa64_to_int (buf
[23]) << 18;
1445 digest
[17] = (l
>> 0) & 0xff;
1446 digest
[16] = (l
>> 8) & 0xff;
1447 digest
[15] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[24]) << 0;
1450 l
|= itoa64_to_int (buf
[25]) << 6;
1451 l
|= itoa64_to_int (buf
[26]) << 12;
1452 l
|= itoa64_to_int (buf
[27]) << 18;
1454 digest
[20] = (l
>> 0) & 0xff;
1455 digest
[19] = (l
>> 8) & 0xff;
1456 digest
[18] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[28]) << 0;
1459 l
|= itoa64_to_int (buf
[29]) << 6;
1460 l
|= itoa64_to_int (buf
[30]) << 12;
1461 l
|= itoa64_to_int (buf
[31]) << 18;
1463 digest
[23] = (l
>> 0) & 0xff;
1464 digest
[22] = (l
>> 8) & 0xff;
1465 digest
[21] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[32]) << 0;
1468 l
|= itoa64_to_int (buf
[33]) << 6;
1469 l
|= itoa64_to_int (buf
[34]) << 12;
1470 l
|= itoa64_to_int (buf
[35]) << 18;
1472 digest
[26] = (l
>> 0) & 0xff;
1473 digest
[25] = (l
>> 8) & 0xff;
1474 digest
[24] = (l
>> 16) & 0xff;
1476 l
= itoa64_to_int (buf
[36]) << 0;
1477 l
|= itoa64_to_int (buf
[37]) << 6;
1478 l
|= itoa64_to_int (buf
[38]) << 12;
1479 l
|= itoa64_to_int (buf
[39]) << 18;
1481 digest
[29] = (l
>> 0) & 0xff;
1482 digest
[28] = (l
>> 8) & 0xff;
1483 digest
[27] = (l
>> 16) & 0xff;
1485 l
= itoa64_to_int (buf
[40]) << 0;
1486 l
|= itoa64_to_int (buf
[41]) << 6;
1487 l
|= itoa64_to_int (buf
[42]) << 12;
1489 //digest[32] = (l >> 0) & 0xff;
1490 digest
[31] = (l
>> 8) & 0xff;
1491 digest
[30] = (l
>> 16) & 0xff;
1494 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1498 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1500 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1507 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1514 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[11] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1521 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[15] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1528 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[19] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1535 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[23] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1542 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[27] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1549 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[31] = int_to_itoa64 (l
& 0x3f);
1554 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1556 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[35] = int_to_itoa64 (l
& 0x3f);
1561 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1563 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1565 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1566 buf
[39] = int_to_itoa64 (l
& 0x3f);
1568 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1570 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1572 buf
[42] = int_to_itoa64 (l
& 0x3f);
1575 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1579 l
= itoa64_to_int (buf
[ 0]) << 0;
1580 l
|= itoa64_to_int (buf
[ 1]) << 6;
1581 l
|= itoa64_to_int (buf
[ 2]) << 12;
1582 l
|= itoa64_to_int (buf
[ 3]) << 18;
1584 digest
[ 2] = (l
>> 0) & 0xff;
1585 digest
[ 1] = (l
>> 8) & 0xff;
1586 digest
[ 0] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[ 4]) << 0;
1589 l
|= itoa64_to_int (buf
[ 5]) << 6;
1590 l
|= itoa64_to_int (buf
[ 6]) << 12;
1591 l
|= itoa64_to_int (buf
[ 7]) << 18;
1593 digest
[ 5] = (l
>> 0) & 0xff;
1594 digest
[ 4] = (l
>> 8) & 0xff;
1595 digest
[ 3] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[ 8]) << 0;
1598 l
|= itoa64_to_int (buf
[ 9]) << 6;
1599 l
|= itoa64_to_int (buf
[10]) << 12;
1600 l
|= itoa64_to_int (buf
[11]) << 18;
1602 digest
[ 8] = (l
>> 0) & 0xff;
1603 digest
[ 7] = (l
>> 8) & 0xff;
1604 digest
[ 6] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[12]) << 0;
1607 l
|= itoa64_to_int (buf
[13]) << 6;
1608 l
|= itoa64_to_int (buf
[14]) << 12;
1609 l
|= itoa64_to_int (buf
[15]) << 18;
1611 digest
[11] = (l
>> 0) & 0xff;
1612 digest
[10] = (l
>> 8) & 0xff;
1613 digest
[ 9] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[16]) << 0;
1616 l
|= itoa64_to_int (buf
[17]) << 6;
1617 l
|= itoa64_to_int (buf
[18]) << 12;
1618 l
|= itoa64_to_int (buf
[19]) << 18;
1620 digest
[14] = (l
>> 0) & 0xff;
1621 digest
[13] = (l
>> 8) & 0xff;
1622 digest
[12] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[20]) << 0;
1625 l
|= itoa64_to_int (buf
[21]) << 6;
1626 l
|= itoa64_to_int (buf
[22]) << 12;
1627 l
|= itoa64_to_int (buf
[23]) << 18;
1629 digest
[17] = (l
>> 0) & 0xff;
1630 digest
[16] = (l
>> 8) & 0xff;
1631 digest
[15] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[24]) << 0;
1634 l
|= itoa64_to_int (buf
[25]) << 6;
1635 l
|= itoa64_to_int (buf
[26]) << 12;
1636 l
|= itoa64_to_int (buf
[27]) << 18;
1638 digest
[20] = (l
>> 0) & 0xff;
1639 digest
[19] = (l
>> 8) & 0xff;
1640 digest
[18] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[28]) << 0;
1643 l
|= itoa64_to_int (buf
[29]) << 6;
1644 l
|= itoa64_to_int (buf
[30]) << 12;
1645 l
|= itoa64_to_int (buf
[31]) << 18;
1647 digest
[23] = (l
>> 0) & 0xff;
1648 digest
[22] = (l
>> 8) & 0xff;
1649 digest
[21] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[32]) << 0;
1652 l
|= itoa64_to_int (buf
[33]) << 6;
1653 l
|= itoa64_to_int (buf
[34]) << 12;
1654 l
|= itoa64_to_int (buf
[35]) << 18;
1656 digest
[26] = (l
>> 0) & 0xff;
1657 digest
[25] = (l
>> 8) & 0xff;
1658 digest
[24] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[36]) << 0;
1661 l
|= itoa64_to_int (buf
[37]) << 6;
1662 l
|= itoa64_to_int (buf
[38]) << 12;
1663 l
|= itoa64_to_int (buf
[39]) << 18;
1665 digest
[29] = (l
>> 0) & 0xff;
1666 digest
[28] = (l
>> 8) & 0xff;
1667 digest
[27] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[40]) << 0;
1670 l
|= itoa64_to_int (buf
[41]) << 6;
1671 l
|= itoa64_to_int (buf
[42]) << 12;
1672 l
|= itoa64_to_int (buf
[43]) << 18;
1674 digest
[32] = (l
>> 0) & 0xff;
1675 digest
[31] = (l
>> 8) & 0xff;
1676 digest
[30] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[44]) << 0;
1679 l
|= itoa64_to_int (buf
[45]) << 6;
1680 l
|= itoa64_to_int (buf
[46]) << 12;
1681 l
|= itoa64_to_int (buf
[47]) << 18;
1683 digest
[35] = (l
>> 0) & 0xff;
1684 digest
[34] = (l
>> 8) & 0xff;
1685 digest
[33] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[48]) << 0;
1688 l
|= itoa64_to_int (buf
[49]) << 6;
1689 l
|= itoa64_to_int (buf
[50]) << 12;
1690 l
|= itoa64_to_int (buf
[51]) << 18;
1692 digest
[38] = (l
>> 0) & 0xff;
1693 digest
[37] = (l
>> 8) & 0xff;
1694 digest
[36] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[52]) << 0;
1697 l
|= itoa64_to_int (buf
[53]) << 6;
1698 l
|= itoa64_to_int (buf
[54]) << 12;
1699 l
|= itoa64_to_int (buf
[55]) << 18;
1701 digest
[41] = (l
>> 0) & 0xff;
1702 digest
[40] = (l
>> 8) & 0xff;
1703 digest
[39] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[56]) << 0;
1706 l
|= itoa64_to_int (buf
[57]) << 6;
1707 l
|= itoa64_to_int (buf
[58]) << 12;
1708 l
|= itoa64_to_int (buf
[59]) << 18;
1710 digest
[44] = (l
>> 0) & 0xff;
1711 digest
[43] = (l
>> 8) & 0xff;
1712 digest
[42] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[60]) << 0;
1715 l
|= itoa64_to_int (buf
[61]) << 6;
1716 l
|= itoa64_to_int (buf
[62]) << 12;
1717 l
|= itoa64_to_int (buf
[63]) << 18;
1719 digest
[47] = (l
>> 0) & 0xff;
1720 digest
[46] = (l
>> 8) & 0xff;
1721 digest
[45] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[64]) << 0;
1724 l
|= itoa64_to_int (buf
[65]) << 6;
1725 l
|= itoa64_to_int (buf
[66]) << 12;
1726 l
|= itoa64_to_int (buf
[67]) << 18;
1728 digest
[50] = (l
>> 0) & 0xff;
1729 digest
[49] = (l
>> 8) & 0xff;
1730 digest
[48] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[68]) << 0;
1733 l
|= itoa64_to_int (buf
[69]) << 6;
1734 l
|= itoa64_to_int (buf
[70]) << 12;
1735 l
|= itoa64_to_int (buf
[71]) << 18;
1737 digest
[53] = (l
>> 0) & 0xff;
1738 digest
[52] = (l
>> 8) & 0xff;
1739 digest
[51] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[72]) << 0;
1742 l
|= itoa64_to_int (buf
[73]) << 6;
1743 l
|= itoa64_to_int (buf
[74]) << 12;
1744 l
|= itoa64_to_int (buf
[75]) << 18;
1746 digest
[56] = (l
>> 0) & 0xff;
1747 digest
[55] = (l
>> 8) & 0xff;
1748 digest
[54] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[76]) << 0;
1751 l
|= itoa64_to_int (buf
[77]) << 6;
1752 l
|= itoa64_to_int (buf
[78]) << 12;
1753 l
|= itoa64_to_int (buf
[79]) << 18;
1755 digest
[59] = (l
>> 0) & 0xff;
1756 digest
[58] = (l
>> 8) & 0xff;
1757 digest
[57] = (l
>> 16) & 0xff;
1759 l
= itoa64_to_int (buf
[80]) << 0;
1760 l
|= itoa64_to_int (buf
[81]) << 6;
1761 l
|= itoa64_to_int (buf
[82]) << 12;
1762 l
|= itoa64_to_int (buf
[83]) << 18;
1764 digest
[62] = (l
>> 0) & 0xff;
1765 digest
[61] = (l
>> 8) & 0xff;
1766 digest
[60] = (l
>> 16) & 0xff;
1768 l
= itoa64_to_int (buf
[84]) << 0;
1769 l
|= itoa64_to_int (buf
[85]) << 6;
1771 digest
[63] = (l
>> 16) & 0xff;
1774 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1778 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1780 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1787 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1794 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[11] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1801 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[15] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1808 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[19] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1815 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[23] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1822 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[27] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1829 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[31] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1836 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[35] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1843 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[39] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1850 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[43] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1857 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[47] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1864 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[51] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1871 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[55] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1878 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[59] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1885 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[63] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1892 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[67] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1899 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[71] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1906 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[75] = int_to_itoa64 (l
& 0x3f);
1911 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1913 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1915 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[79] = int_to_itoa64 (l
& 0x3f);
1918 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1920 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1922 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1923 buf
[83] = int_to_itoa64 (l
& 0x3f);
1925 l
= 0 | 0 | (digest
[63] << 16);
1927 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1931 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1935 l
= itoa64_to_int (buf
[ 0]) << 0;
1936 l
|= itoa64_to_int (buf
[ 1]) << 6;
1937 l
|= itoa64_to_int (buf
[ 2]) << 12;
1938 l
|= itoa64_to_int (buf
[ 3]) << 18;
1940 digest
[ 0] = (l
>> 16) & 0xff;
1941 digest
[10] = (l
>> 8) & 0xff;
1942 digest
[20] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[ 4]) << 0;
1945 l
|= itoa64_to_int (buf
[ 5]) << 6;
1946 l
|= itoa64_to_int (buf
[ 6]) << 12;
1947 l
|= itoa64_to_int (buf
[ 7]) << 18;
1949 digest
[21] = (l
>> 16) & 0xff;
1950 digest
[ 1] = (l
>> 8) & 0xff;
1951 digest
[11] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[ 8]) << 0;
1954 l
|= itoa64_to_int (buf
[ 9]) << 6;
1955 l
|= itoa64_to_int (buf
[10]) << 12;
1956 l
|= itoa64_to_int (buf
[11]) << 18;
1958 digest
[12] = (l
>> 16) & 0xff;
1959 digest
[22] = (l
>> 8) & 0xff;
1960 digest
[ 2] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[12]) << 0;
1963 l
|= itoa64_to_int (buf
[13]) << 6;
1964 l
|= itoa64_to_int (buf
[14]) << 12;
1965 l
|= itoa64_to_int (buf
[15]) << 18;
1967 digest
[ 3] = (l
>> 16) & 0xff;
1968 digest
[13] = (l
>> 8) & 0xff;
1969 digest
[23] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[16]) << 0;
1972 l
|= itoa64_to_int (buf
[17]) << 6;
1973 l
|= itoa64_to_int (buf
[18]) << 12;
1974 l
|= itoa64_to_int (buf
[19]) << 18;
1976 digest
[24] = (l
>> 16) & 0xff;
1977 digest
[ 4] = (l
>> 8) & 0xff;
1978 digest
[14] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[20]) << 0;
1981 l
|= itoa64_to_int (buf
[21]) << 6;
1982 l
|= itoa64_to_int (buf
[22]) << 12;
1983 l
|= itoa64_to_int (buf
[23]) << 18;
1985 digest
[15] = (l
>> 16) & 0xff;
1986 digest
[25] = (l
>> 8) & 0xff;
1987 digest
[ 5] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[24]) << 0;
1990 l
|= itoa64_to_int (buf
[25]) << 6;
1991 l
|= itoa64_to_int (buf
[26]) << 12;
1992 l
|= itoa64_to_int (buf
[27]) << 18;
1994 digest
[ 6] = (l
>> 16) & 0xff;
1995 digest
[16] = (l
>> 8) & 0xff;
1996 digest
[26] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[28]) << 0;
1999 l
|= itoa64_to_int (buf
[29]) << 6;
2000 l
|= itoa64_to_int (buf
[30]) << 12;
2001 l
|= itoa64_to_int (buf
[31]) << 18;
2003 digest
[27] = (l
>> 16) & 0xff;
2004 digest
[ 7] = (l
>> 8) & 0xff;
2005 digest
[17] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[32]) << 0;
2008 l
|= itoa64_to_int (buf
[33]) << 6;
2009 l
|= itoa64_to_int (buf
[34]) << 12;
2010 l
|= itoa64_to_int (buf
[35]) << 18;
2012 digest
[18] = (l
>> 16) & 0xff;
2013 digest
[28] = (l
>> 8) & 0xff;
2014 digest
[ 8] = (l
>> 0) & 0xff;
2016 l
= itoa64_to_int (buf
[36]) << 0;
2017 l
|= itoa64_to_int (buf
[37]) << 6;
2018 l
|= itoa64_to_int (buf
[38]) << 12;
2019 l
|= itoa64_to_int (buf
[39]) << 18;
2021 digest
[ 9] = (l
>> 16) & 0xff;
2022 digest
[19] = (l
>> 8) & 0xff;
2023 digest
[29] = (l
>> 0) & 0xff;
2025 l
= itoa64_to_int (buf
[40]) << 0;
2026 l
|= itoa64_to_int (buf
[41]) << 6;
2027 l
|= itoa64_to_int (buf
[42]) << 12;
2029 digest
[31] = (l
>> 8) & 0xff;
2030 digest
[30] = (l
>> 0) & 0xff;
2033 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2037 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2039 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2046 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2053 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2060 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2067 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2074 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2081 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2088 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2095 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2102 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2104 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2107 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2109 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2111 buf
[42] = int_to_itoa64 (l
& 0x3f);
2114 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2118 l
= itoa64_to_int (buf
[ 0]) << 0;
2119 l
|= itoa64_to_int (buf
[ 1]) << 6;
2120 l
|= itoa64_to_int (buf
[ 2]) << 12;
2121 l
|= itoa64_to_int (buf
[ 3]) << 18;
2123 digest
[ 0] = (l
>> 0) & 0xff;
2124 digest
[ 1] = (l
>> 8) & 0xff;
2125 digest
[ 2] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[ 4]) << 0;
2128 l
|= itoa64_to_int (buf
[ 5]) << 6;
2129 l
|= itoa64_to_int (buf
[ 6]) << 12;
2130 l
|= itoa64_to_int (buf
[ 7]) << 18;
2132 digest
[ 3] = (l
>> 0) & 0xff;
2133 digest
[ 4] = (l
>> 8) & 0xff;
2134 digest
[ 5] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[ 8]) << 0;
2137 l
|= itoa64_to_int (buf
[ 9]) << 6;
2138 l
|= itoa64_to_int (buf
[10]) << 12;
2139 l
|= itoa64_to_int (buf
[11]) << 18;
2141 digest
[ 6] = (l
>> 0) & 0xff;
2142 digest
[ 7] = (l
>> 8) & 0xff;
2143 digest
[ 8] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[12]) << 0;
2146 l
|= itoa64_to_int (buf
[13]) << 6;
2147 l
|= itoa64_to_int (buf
[14]) << 12;
2148 l
|= itoa64_to_int (buf
[15]) << 18;
2150 digest
[ 9] = (l
>> 0) & 0xff;
2151 digest
[10] = (l
>> 8) & 0xff;
2152 digest
[11] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[16]) << 0;
2155 l
|= itoa64_to_int (buf
[17]) << 6;
2156 l
|= itoa64_to_int (buf
[18]) << 12;
2157 l
|= itoa64_to_int (buf
[19]) << 18;
2159 digest
[12] = (l
>> 0) & 0xff;
2160 digest
[13] = (l
>> 8) & 0xff;
2161 digest
[14] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[20]) << 0;
2164 l
|= itoa64_to_int (buf
[21]) << 6;
2165 l
|= itoa64_to_int (buf
[22]) << 12;
2166 l
|= itoa64_to_int (buf
[23]) << 18;
2168 digest
[15] = (l
>> 0) & 0xff;
2169 digest
[16] = (l
>> 8) & 0xff;
2170 digest
[17] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[24]) << 0;
2173 l
|= itoa64_to_int (buf
[25]) << 6;
2174 l
|= itoa64_to_int (buf
[26]) << 12;
2175 l
|= itoa64_to_int (buf
[27]) << 18;
2177 digest
[18] = (l
>> 0) & 0xff;
2178 digest
[19] = (l
>> 8) & 0xff;
2179 digest
[20] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[28]) << 0;
2182 l
|= itoa64_to_int (buf
[29]) << 6;
2183 l
|= itoa64_to_int (buf
[30]) << 12;
2184 l
|= itoa64_to_int (buf
[31]) << 18;
2186 digest
[21] = (l
>> 0) & 0xff;
2187 digest
[22] = (l
>> 8) & 0xff;
2188 digest
[23] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[32]) << 0;
2191 l
|= itoa64_to_int (buf
[33]) << 6;
2192 l
|= itoa64_to_int (buf
[34]) << 12;
2193 l
|= itoa64_to_int (buf
[35]) << 18;
2195 digest
[24] = (l
>> 0) & 0xff;
2196 digest
[25] = (l
>> 8) & 0xff;
2197 digest
[26] = (l
>> 16) & 0xff;
2199 l
= itoa64_to_int (buf
[36]) << 0;
2200 l
|= itoa64_to_int (buf
[37]) << 6;
2201 l
|= itoa64_to_int (buf
[38]) << 12;
2202 l
|= itoa64_to_int (buf
[39]) << 18;
2204 digest
[27] = (l
>> 0) & 0xff;
2205 digest
[28] = (l
>> 8) & 0xff;
2206 digest
[29] = (l
>> 16) & 0xff;
2208 l
= itoa64_to_int (buf
[40]) << 0;
2209 l
|= itoa64_to_int (buf
[41]) << 6;
2210 l
|= itoa64_to_int (buf
[42]) << 12;
2211 l
|= itoa64_to_int (buf
[43]) << 18;
2213 digest
[30] = (l
>> 0) & 0xff;
2214 digest
[31] = (l
>> 8) & 0xff;
2215 digest
[32] = (l
>> 16) & 0xff;
2250 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2254 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2256 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2263 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2270 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[11] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2277 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[15] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2284 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[19] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2291 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[23] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2298 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[27] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2305 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[31] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2312 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[35] = int_to_itoa64 (l
& 0x3f);
2317 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2319 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2321 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2322 buf
[39] = int_to_itoa64 (l
& 0x3f);
2324 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2326 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2328 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2329 //buf[43] = int_to_itoa64 (l & 0x3f);
2337 static struct termio savemodes
;
2338 static int havemodes
= 0;
2342 struct termio modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
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)
3427 if (data
.hm_device
[device_id
].od_version
== 5)
3429 ADLFanSpeedValue lpFanSpeedValue
;
3431 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3433 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3434 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3435 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3436 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3438 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3442 else // od_version == 6
3444 ADLOD6FanSpeedValue fan_speed_value
;
3446 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3448 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3449 fan_speed_value
.iFanSpeed
= fanspeed
;
3451 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3461 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3463 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3467 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3469 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3471 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3472 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3474 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3483 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3485 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3487 if (data
.hm_xnvctrl
)
3489 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3498 #endif // HAVE_HWMON
3504 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3506 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3508 if (css_cnt
> SP_PW_MAX
)
3510 log_error ("ERROR: Mask length is too long");
3515 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3517 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3519 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3520 uint cs_len
= css
[css_pos
].cs_len
;
3522 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3524 uint c
= cs_buf
[cs_pos
] & 0xff;
3531 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3533 cs_t
*cs
= &css
[css_cnt
];
3535 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3537 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3541 for (i
= 0; i
< cs
->cs_len
; i
++)
3543 const uint u
= cs
->cs_buf
[i
];
3548 for (i
= 0; i
< in_len
; i
++)
3550 uint u
= in_buf
[i
] & 0xff;
3552 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3554 if (css_uniq
[u
] == 1) continue;
3558 cs
->cs_buf
[cs
->cs_len
] = u
;
3566 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3570 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3572 uint p0
= in_buf
[in_pos
] & 0xff;
3574 if (interpret
== 1 && p0
== '?')
3578 if (in_pos
== in_len
) break;
3580 uint p1
= in_buf
[in_pos
] & 0xff;
3584 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3586 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3588 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3590 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3592 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3594 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3596 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3597 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3599 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3600 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3602 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3603 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3605 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3606 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3608 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3610 default: log_error ("Syntax error: %s", in_buf
);
3616 if (data
.hex_charset
)
3620 if (in_pos
== in_len
)
3622 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3627 uint p1
= in_buf
[in_pos
] & 0xff;
3629 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3631 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3638 chr
= hex_convert (p1
) << 0;
3639 chr
|= hex_convert (p0
) << 4;
3641 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3647 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3653 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3657 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3659 sum
*= css
[css_pos
].cs_len
;
3665 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3667 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3672 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3674 char p0
= mask_buf
[mask_pos
];
3680 if (mask_pos
== mask_len
) break;
3682 char p1
= mask_buf
[mask_pos
];
3688 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3690 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3692 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3694 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3696 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3698 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3700 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3701 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3703 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3704 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3706 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3707 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3709 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3710 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3712 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3714 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3720 if (data
.hex_charset
)
3724 // if there is no 2nd hex character, show an error:
3726 if (mask_pos
== mask_len
)
3728 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3733 char p1
= mask_buf
[mask_pos
];
3735 // if they are not valid hex character, show an error:
3737 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3739 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3746 chr
|= hex_convert (p1
) << 0;
3747 chr
|= hex_convert (p0
) << 4;
3749 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3755 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3762 log_error ("ERROR: Invalid mask length (0)");
3772 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3774 for (int i
= 0; i
< css_cnt
; i
++)
3776 uint len
= css
[i
].cs_len
;
3777 u64 next
= val
/ len
;
3778 uint pos
= val
% len
;
3779 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3784 void mp_cut_at (char *mask
, uint max
)
3788 uint mask_len
= strlen (mask
);
3790 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3792 if (mask
[i
] == '?') i
++;
3798 void mp_setup_sys (cs_t
*mp_sys
)
3802 uint donec
[CHARSIZ
] = { 0 };
3804 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3805 mp_sys
[0].cs_buf
[pos
++] = chr
;
3806 mp_sys
[0].cs_len
= pos
; }
3808 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3809 mp_sys
[1].cs_buf
[pos
++] = chr
;
3810 mp_sys
[1].cs_len
= pos
; }
3812 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3813 mp_sys
[2].cs_buf
[pos
++] = chr
;
3814 mp_sys
[2].cs_len
= pos
; }
3816 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3817 mp_sys
[3].cs_buf
[pos
++] = chr
;
3818 mp_sys
[3].cs_len
= pos
; }
3820 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3821 mp_sys
[4].cs_len
= pos
; }
3823 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3824 mp_sys
[5].cs_len
= pos
; }
3827 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3829 FILE *fp
= fopen (buf
, "rb");
3831 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3833 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3837 char mp_file
[1024] = { 0 };
3839 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3843 len
= in_superchop (mp_file
);
3847 log_info ("WARNING: Charset file corrupted");
3849 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3853 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3858 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3860 mp_usr
[index
].cs_len
= 0;
3862 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3865 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3867 char *new_mask_buf
= (char *) mymalloc (256);
3873 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3875 if (css_pos
== len
) break;
3877 char p0
= mask_buf
[mask_pos
];
3879 new_mask_buf
[mask_pos
] = p0
;
3885 if (mask_pos
== mask_len
) break;
3887 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3891 if (data
.hex_charset
)
3895 if (mask_pos
== mask_len
)
3897 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3902 char p1
= mask_buf
[mask_pos
];
3904 // if they are not valid hex character, show an error:
3906 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3908 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3913 new_mask_buf
[mask_pos
] = p1
;
3918 if (css_pos
== len
) return (new_mask_buf
);
3920 myfree (new_mask_buf
);
3929 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3935 for (i
= start
; i
< stop
; i
++)
3937 sum
*= root_css_buf
[i
].cs_len
;
3943 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3947 cs_t
*cs
= &root_css_buf
[start
];
3951 for (i
= start
; i
< stop
; i
++)
3953 const u64 m
= v
% cs
->cs_len
;
3954 const u64 d
= v
/ cs
->cs_len
;
3958 const uint k
= cs
->cs_buf
[m
];
3960 pw_buf
[i
- start
] = (char) k
;
3962 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3966 int sp_comp_val (const void *p1
, const void *p2
)
3968 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3969 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3971 return b2
->val
- b1
->val
;
3974 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
)
3981 * Initialize hcstats
3984 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3986 u64
*root_stats_ptr
= root_stats_buf
;
3988 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3990 for (i
= 0; i
< SP_PW_MAX
; i
++)
3992 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3994 root_stats_ptr
+= CHARSIZ
;
3997 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3999 u64
*markov_stats_ptr
= markov_stats_buf
;
4001 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4003 for (i
= 0; i
< SP_PW_MAX
; i
++)
4005 for (j
= 0; j
< CHARSIZ
; j
++)
4007 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4009 markov_stats_ptr
+= CHARSIZ
;
4019 char hcstat_tmp
[256] = { 0 };
4021 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4023 hcstat
= hcstat_tmp
;
4026 FILE *fd
= fopen (hcstat
, "rb");
4030 log_error ("%s: %s", hcstat
, strerror (errno
));
4035 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4037 log_error ("%s: Could not load data", hcstat
);
4044 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4046 log_error ("%s: Could not load data", hcstat
);
4056 * Markov modifier of hcstat_table on user request
4061 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4062 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4067 /* Add all stats to first position */
4069 for (i
= 1; i
< SP_PW_MAX
; i
++)
4071 u64
*out
= root_stats_buf_by_pos
[0];
4072 u64
*in
= root_stats_buf_by_pos
[i
];
4074 for (j
= 0; j
< CHARSIZ
; j
++)
4080 for (i
= 1; i
< SP_PW_MAX
; i
++)
4082 u64
*out
= markov_stats_buf_by_key
[0][0];
4083 u64
*in
= markov_stats_buf_by_key
[i
][0];
4085 for (j
= 0; j
< CHARSIZ
; j
++)
4087 for (k
= 0; k
< CHARSIZ
; k
++)
4094 /* copy them to all pw_positions */
4096 for (i
= 1; i
< SP_PW_MAX
; i
++)
4098 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4101 for (i
= 1; i
< SP_PW_MAX
; i
++)
4103 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4111 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4113 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4115 for (i
= 0; i
< SP_PW_MAX
; i
++)
4117 root_table_buf_by_pos
[i
] = root_table_ptr
;
4119 root_table_ptr
+= CHARSIZ
;
4122 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4124 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4126 for (i
= 0; i
< SP_PW_MAX
; i
++)
4128 for (j
= 0; j
< CHARSIZ
; j
++)
4130 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4132 markov_table_ptr
+= CHARSIZ
;
4137 * Convert hcstat to tables
4140 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4142 uint key
= i
% CHARSIZ
;
4144 root_table_buf
[i
].key
= key
;
4145 root_table_buf
[i
].val
= root_stats_buf
[i
];
4148 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4150 uint key
= i
% CHARSIZ
;
4152 markov_table_buf
[i
].key
= key
;
4153 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4156 myfree (root_stats_buf
);
4157 myfree (markov_stats_buf
);
4163 for (i
= 0; i
< SP_PW_MAX
; i
++)
4165 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4168 for (i
= 0; i
< SP_PW_MAX
; i
++)
4170 for (j
= 0; j
< CHARSIZ
; j
++)
4172 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4177 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
])
4180 * Convert tables to css
4183 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4185 uint pw_pos
= i
/ CHARSIZ
;
4187 cs_t
*cs
= &root_css_buf
[pw_pos
];
4189 if (cs
->cs_len
== threshold
) continue;
4191 uint key
= root_table_buf
[i
].key
;
4193 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4195 cs
->cs_buf
[cs
->cs_len
] = key
;
4201 * Convert table to css
4204 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4206 uint c
= i
/ CHARSIZ
;
4208 cs_t
*cs
= &markov_css_buf
[c
];
4210 if (cs
->cs_len
== threshold
) continue;
4212 uint pw_pos
= c
/ CHARSIZ
;
4214 uint key
= markov_table_buf
[i
].key
;
4216 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4218 cs
->cs_buf
[cs
->cs_len
] = key
;
4224 for (uint i = 0; i < 8; i++)
4226 for (uint j = 0x20; j < 0x80; j++)
4228 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4230 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4232 for (uint k = 0; k < 10; k++)
4234 printf (" %u\n", ptr->cs_buf[k]);
4241 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4243 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4245 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4255 for (uint j
= 1; j
< CHARSIZ
; j
++)
4265 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4267 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4269 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4271 out
+= CHARSIZ
* CHARSIZ
;
4272 in
+= CHARSIZ
* CHARSIZ
;
4274 for (uint j
= 0; j
< CHARSIZ
; j
++)
4281 for (uint k
= 1; k
< CHARSIZ
; k
++)
4293 * mixed shared functions
4296 void dump_hex (const u8
*s
, const int sz
)
4298 for (int i
= 0; i
< sz
; i
++)
4300 log_info_nn ("%02x ", s
[i
]);
4306 void usage_mini_print (const char *progname
)
4308 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4311 void usage_big_print (const char *progname
)
4313 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4316 char *get_exec_path ()
4318 int exec_path_len
= 1024;
4320 char *exec_path
= (char *) mymalloc (exec_path_len
);
4324 char tmp
[32] = { 0 };
4326 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4328 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4332 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4336 uint size
= exec_path_len
;
4338 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4340 log_error("! executable path buffer too small\n");
4345 const int len
= strlen (exec_path
);
4348 #error Your Operating System is not supported or detected
4356 char *get_install_dir (const char *progname
)
4358 char *install_dir
= mystrdup (progname
);
4359 char *last_slash
= NULL
;
4361 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4365 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4371 install_dir
[0] = '.';
4375 return (install_dir
);
4378 char *get_profile_dir (const char *homedir
)
4380 #define DOT_HASHCAT ".hashcat"
4382 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4384 char *profile_dir
= (char *) mymalloc (len
+ 1);
4386 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4391 char *get_session_dir (const char *profile_dir
)
4393 #define SESSIONS_FOLDER "sessions"
4395 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4397 char *session_dir
= (char *) mymalloc (len
+ 1);
4399 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4404 uint
count_lines (FILE *fd
)
4408 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4414 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4416 if (nread
< 1) continue;
4420 for (i
= 0; i
< nread
; i
++)
4422 if (prev
== '\n') cnt
++;
4433 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4437 FILE *fd
= fopen (filename
, "rb");
4441 log_error ("%s: %s", filename
, strerror (errno
));
4446 #define MAX_KEY_SIZE (1024 * 1024)
4448 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4450 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4456 for (int fpos
= 0; fpos
< nread
; fpos
++)
4458 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4460 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4461 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4462 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4463 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4465 if (kpos
>= 64) kpos
= 0;
4472 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4476 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4477 if (CPU_ISSET(core
, cpu_set
)) break;
4479 thread_affinity_policy_data_t policy
= { core
};
4481 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4483 if (data
.quiet
== 0)
4485 if (rc
!= KERN_SUCCESS
)
4487 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4495 void set_cpu_affinity (char *cpu_affinity
)
4498 DWORD_PTR aff_mask
= 0;
4506 char *devices
= strdup (cpu_affinity
);
4508 char *next
= strtok (devices
, ",");
4512 uint cpu_id
= atoi (next
);
4527 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4533 aff_mask
|= 1 << (cpu_id
- 1);
4535 CPU_SET ((cpu_id
- 1), &cpuset
);
4538 } while ((next
= strtok (NULL
, ",")) != NULL
);
4544 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4545 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4547 pthread_t thread
= pthread_self ();
4548 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4552 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4554 char *element
, *end
;
4556 end
= (char *) base
+ nmemb
* size
;
4558 for (element
= (char *) base
; element
< end
; element
+= size
)
4559 if (!compar (element
, key
))
4565 int sort_by_u32 (const void *v1
, const void *v2
)
4567 const u32
*s1
= (const u32
*) v1
;
4568 const u32
*s2
= (const u32
*) v2
;
4573 int sort_by_salt (const void *v1
, const void *v2
)
4575 const salt_t
*s1
= (const salt_t
*) v1
;
4576 const salt_t
*s2
= (const salt_t
*) v2
;
4578 const int res1
= s1
->salt_len
- s2
->salt_len
;
4580 if (res1
!= 0) return (res1
);
4582 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4584 if (res2
!= 0) return (res2
);
4592 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4593 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4600 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4601 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4607 int sort_by_salt_buf (const void *v1
, const void *v2
)
4609 const pot_t
*p1
= (const pot_t
*) v1
;
4610 const pot_t
*p2
= (const pot_t
*) v2
;
4612 const hash_t
*h1
= &p1
->hash
;
4613 const hash_t
*h2
= &p2
->hash
;
4615 const salt_t
*s1
= h1
->salt
;
4616 const salt_t
*s2
= h2
->salt
;
4622 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4623 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4629 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4631 const hash_t
*h1
= (const hash_t
*) v1
;
4632 const hash_t
*h2
= (const hash_t
*) v2
;
4634 const salt_t
*s1
= h1
->salt
;
4635 const salt_t
*s2
= h2
->salt
;
4637 // testphase: this should work
4642 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4643 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4646 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4647 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4648 if (s1->salt_len > s2->salt_len) return ( 1);
4649 if (s1->salt_len < s2->salt_len) return (-1);
4651 uint n = s1->salt_len;
4655 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4656 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4663 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4665 const hash_t
*h1
= (const hash_t
*) v1
;
4666 const hash_t
*h2
= (const hash_t
*) v2
;
4668 const salt_t
*s1
= h1
->salt
;
4669 const salt_t
*s2
= h2
->salt
;
4671 // 16 - 2 (since last 2 uints contain the digest)
4676 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4677 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4683 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4685 const hash_t
*h1
= (const hash_t
*) v1
;
4686 const hash_t
*h2
= (const hash_t
*) v2
;
4688 const void *d1
= h1
->digest
;
4689 const void *d2
= h2
->digest
;
4691 return data
.sort_by_digest (d1
, d2
);
4694 int sort_by_hash (const void *v1
, const void *v2
)
4696 const hash_t
*h1
= (const hash_t
*) v1
;
4697 const hash_t
*h2
= (const hash_t
*) v2
;
4701 const salt_t
*s1
= h1
->salt
;
4702 const salt_t
*s2
= h2
->salt
;
4704 int res
= sort_by_salt (s1
, s2
);
4706 if (res
!= 0) return (res
);
4709 const void *d1
= h1
->digest
;
4710 const void *d2
= h2
->digest
;
4712 return data
.sort_by_digest (d1
, d2
);
4715 int sort_by_pot (const void *v1
, const void *v2
)
4717 const pot_t
*p1
= (const pot_t
*) v1
;
4718 const pot_t
*p2
= (const pot_t
*) v2
;
4720 const hash_t
*h1
= &p1
->hash
;
4721 const hash_t
*h2
= &p2
->hash
;
4723 return sort_by_hash (h1
, h2
);
4726 int sort_by_mtime (const void *p1
, const void *p2
)
4728 const char **f1
= (const char **) p1
;
4729 const char **f2
= (const char **) p2
;
4731 struct stat s1
; stat (*f1
, &s1
);
4732 struct stat s2
; stat (*f2
, &s2
);
4734 return s2
.st_mtime
- s1
.st_mtime
;
4737 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4739 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4740 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4742 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4745 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4747 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4748 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4750 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4753 int sort_by_stringptr (const void *p1
, const void *p2
)
4755 const char **s1
= (const char **) p1
;
4756 const char **s2
= (const char **) p2
;
4758 return strcmp (*s1
, *s2
);
4761 int sort_by_dictstat (const void *s1
, const void *s2
)
4763 dictstat_t
*d1
= (dictstat_t
*) s1
;
4764 dictstat_t
*d2
= (dictstat_t
*) s2
;
4767 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4769 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4772 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4775 int sort_by_bitmap (const void *p1
, const void *p2
)
4777 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4778 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4780 return b1
->collisions
- b2
->collisions
;
4783 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4785 const u32
*d1
= (const u32
*) v1
;
4786 const u32
*d2
= (const u32
*) v2
;
4792 if (d1
[n
] > d2
[n
]) return ( 1);
4793 if (d1
[n
] < d2
[n
]) return (-1);
4799 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4801 const u32
*d1
= (const u32
*) v1
;
4802 const u32
*d2
= (const u32
*) v2
;
4808 if (d1
[n
] > d2
[n
]) return ( 1);
4809 if (d1
[n
] < d2
[n
]) return (-1);
4815 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4817 const u32
*d1
= (const u32
*) v1
;
4818 const u32
*d2
= (const u32
*) v2
;
4824 if (d1
[n
] > d2
[n
]) return ( 1);
4825 if (d1
[n
] < d2
[n
]) return (-1);
4831 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4833 const u32
*d1
= (const u32
*) v1
;
4834 const u32
*d2
= (const u32
*) v2
;
4840 if (d1
[n
] > d2
[n
]) return ( 1);
4841 if (d1
[n
] < d2
[n
]) return (-1);
4847 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4849 const u32
*d1
= (const u32
*) v1
;
4850 const u32
*d2
= (const u32
*) v2
;
4856 if (d1
[n
] > d2
[n
]) return ( 1);
4857 if (d1
[n
] < d2
[n
]) return (-1);
4863 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4865 const u32
*d1
= (const u32
*) v1
;
4866 const u32
*d2
= (const u32
*) v2
;
4872 if (d1
[n
] > d2
[n
]) return ( 1);
4873 if (d1
[n
] < d2
[n
]) return (-1);
4879 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4881 const u32
*d1
= (const u32
*) v1
;
4882 const u32
*d2
= (const u32
*) v2
;
4888 if (d1
[n
] > d2
[n
]) return ( 1);
4889 if (d1
[n
] < d2
[n
]) return (-1);
4895 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4897 const u32
*d1
= (const u32
*) v1
;
4898 const u32
*d2
= (const u32
*) v2
;
4904 if (d1
[n
] > d2
[n
]) return ( 1);
4905 if (d1
[n
] < d2
[n
]) return (-1);
4911 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4913 const u64
*d1
= (const u64
*) v1
;
4914 const u64
*d2
= (const u64
*) v2
;
4920 if (d1
[n
] > d2
[n
]) return ( 1);
4921 if (d1
[n
] < d2
[n
]) return (-1);
4927 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4929 const u64
*d1
= (const u64
*) v1
;
4930 const u64
*d2
= (const u64
*) v2
;
4936 if (d1
[n
] > d2
[n
]) return ( 1);
4937 if (d1
[n
] < d2
[n
]) return (-1);
4943 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4945 const u64
*d1
= (const u64
*) v1
;
4946 const u64
*d2
= (const u64
*) v2
;
4952 if (d1
[n
] > d2
[n
]) return ( 1);
4953 if (d1
[n
] < d2
[n
]) return (-1);
4959 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4961 const u32
*d1
= (const u32
*) v1
;
4962 const u32
*d2
= (const u32
*) v2
;
4964 const uint dgst_pos0
= data
.dgst_pos0
;
4965 const uint dgst_pos1
= data
.dgst_pos1
;
4966 const uint dgst_pos2
= data
.dgst_pos2
;
4967 const uint dgst_pos3
= data
.dgst_pos3
;
4969 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4970 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4971 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4972 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4973 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4974 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4975 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4976 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4981 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4983 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4984 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4986 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4988 if (res1
!= 0) return (res1
);
4993 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4995 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4996 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4998 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5000 if (res1
!= 0) return (res1
);
5002 const int res2
= t1
->attack_mode
5005 if (res2
!= 0) return (res2
);
5007 const int res3
= t1
->hash_type
5010 if (res3
!= 0) return (res3
);
5015 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
)
5017 uint outfile_autohex
= data
.outfile_autohex
;
5019 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5021 FILE *debug_fp
= NULL
;
5023 if (debug_file
!= NULL
)
5025 debug_fp
= fopen (debug_file
, "ab");
5027 lock_file (debug_fp
);
5034 if (debug_fp
== NULL
)
5036 log_info ("WARNING: Could not open debug-file for writing");
5040 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5042 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5044 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5047 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5049 if (debug_mode
== 4)
5051 fputc (':', debug_fp
);
5053 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5056 fputc ('\n', debug_fp
);
5058 if (debug_file
!= NULL
) fclose (debug_fp
);
5062 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5064 int needs_hexify
= 0;
5066 if (outfile_autohex
== 1)
5068 for (uint i
= 0; i
< plain_len
; i
++)
5070 if (plain_ptr
[i
] < 0x20)
5077 if (plain_ptr
[i
] > 0x7f)
5086 if (needs_hexify
== 1)
5088 fprintf (fp
, "$HEX[");
5090 for (uint i
= 0; i
< plain_len
; i
++)
5092 fprintf (fp
, "%02x", plain_ptr
[i
]);
5099 fwrite (plain_ptr
, plain_len
, 1, fp
);
5103 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
)
5105 uint outfile_format
= data
.outfile_format
;
5107 char separator
= data
.separator
;
5109 if (outfile_format
& OUTFILE_FMT_HASH
)
5111 fprintf (out_fp
, "%s", out_buf
);
5113 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5115 fputc (separator
, out_fp
);
5118 else if (data
.username
)
5120 if (username
!= NULL
)
5122 for (uint i
= 0; i
< user_len
; i
++)
5124 fprintf (out_fp
, "%c", username
[i
]);
5127 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5129 fputc (separator
, out_fp
);
5134 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5136 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5138 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5140 fputc (separator
, out_fp
);
5144 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5146 for (uint i
= 0; i
< plain_len
; i
++)
5148 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5151 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5153 fputc (separator
, out_fp
);
5157 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5160 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5165 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5167 fprintf (out_fp
, "%llu", crackpos
);
5172 fputc ('\n', out_fp
);
5175 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
)
5179 pot_key
.hash
.salt
= hashes_buf
->salt
;
5180 pot_key
.hash
.digest
= hashes_buf
->digest
;
5182 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5188 input_buf
[input_len
] = 0;
5191 unsigned char *username
= NULL
;
5196 user_t
*user
= hashes_buf
->hash_info
->user
;
5200 username
= (unsigned char *) (user
->user_name
);
5202 user_len
= user
->user_len
;
5206 // do output the line
5207 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5211 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5212 #define LM_MASKED_PLAIN "[notfound]"
5214 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
)
5220 pot_left_key
.hash
.salt
= hash_left
->salt
;
5221 pot_left_key
.hash
.digest
= hash_left
->digest
;
5223 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5227 uint weak_hash_found
= 0;
5229 pot_t pot_right_key
;
5231 pot_right_key
.hash
.salt
= hash_right
->salt
;
5232 pot_right_key
.hash
.digest
= hash_right
->digest
;
5234 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5236 if (pot_right_ptr
== NULL
)
5238 // special case, if "weak hash"
5240 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5242 weak_hash_found
= 1;
5244 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5246 // in theory this is not needed, but we are paranoia:
5248 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5249 pot_right_ptr
->plain_len
= 0;
5253 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5255 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
5260 // at least one half was found:
5264 input_buf
[input_len
] = 0;
5268 unsigned char *username
= NULL
;
5273 user_t
*user
= hash_left
->hash_info
->user
;
5277 username
= (unsigned char *) (user
->user_name
);
5279 user_len
= user
->user_len
;
5283 // mask the part which was not found
5285 uint left_part_masked
= 0;
5286 uint right_part_masked
= 0;
5288 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5290 if (pot_left_ptr
== NULL
)
5292 left_part_masked
= 1;
5294 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5296 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5298 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5299 pot_left_ptr
->plain_len
= mask_plain_len
;
5302 if (pot_right_ptr
== NULL
)
5304 right_part_masked
= 1;
5306 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5308 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5310 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5311 pot_right_ptr
->plain_len
= mask_plain_len
;
5314 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5318 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5320 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5322 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5324 // do output the line
5326 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5328 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5330 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5331 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5334 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
)
5338 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5340 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5342 if (pot_ptr
== NULL
)
5346 input_buf
[input_len
] = 0;
5348 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5352 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
)
5358 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5360 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5364 pot_t pot_right_key
;
5366 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5368 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5370 uint weak_hash_found
= 0;
5372 if (pot_right_ptr
== NULL
)
5374 // special case, if "weak hash"
5376 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5378 weak_hash_found
= 1;
5380 // we just need that pot_right_ptr is not a NULL pointer
5382 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5386 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5388 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5393 // ... at least one part was not cracked
5397 input_buf
[input_len
] = 0;
5399 // only show the hash part which is still not cracked
5401 uint user_len
= input_len
- 32;
5403 char *hash_output
= (char *) mymalloc (33);
5405 memcpy (hash_output
, input_buf
, input_len
);
5407 if (pot_left_ptr
!= NULL
)
5409 // only show right part (because left part was already found)
5411 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5413 hash_output
[user_len
+ 16] = 0;
5416 if (pot_right_ptr
!= NULL
)
5418 // only show left part (because right part was already found)
5420 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5422 hash_output
[user_len
+ 16] = 0;
5425 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5427 myfree (hash_output
);
5429 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5432 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5434 uint opencl_platforms_filter
= 0;
5436 if (opencl_platforms
)
5438 char *platforms
= strdup (opencl_platforms
);
5440 char *next
= strtok (platforms
, ",");
5444 int platform
= atoi (next
);
5446 if (platform
< 1 || platform
> 32)
5448 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5453 opencl_platforms_filter
|= 1 << (platform
- 1);
5455 } while ((next
= strtok (NULL
, ",")) != NULL
);
5461 opencl_platforms_filter
= -1;
5464 return opencl_platforms_filter
;
5467 u32
setup_devices_filter (char *opencl_devices
)
5469 u32 devices_filter
= 0;
5473 char *devices
= strdup (opencl_devices
);
5475 char *next
= strtok (devices
, ",");
5479 int device_id
= atoi (next
);
5481 if (device_id
< 1 || device_id
> 32)
5483 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5488 devices_filter
|= 1 << (device_id
- 1);
5490 } while ((next
= strtok (NULL
, ",")) != NULL
);
5496 devices_filter
= -1;
5499 return devices_filter
;
5502 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5504 cl_device_type device_types_filter
= 0;
5506 if (opencl_device_types
)
5508 char *device_types
= strdup (opencl_device_types
);
5510 char *next
= strtok (device_types
, ",");
5514 int device_type
= atoi (next
);
5516 if (device_type
< 1 || device_type
> 3)
5518 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5523 device_types_filter
|= 1 << device_type
;
5525 } while ((next
= strtok (NULL
, ",")) != NULL
);
5527 free (device_types
);
5531 // Do not use CPU by default, this often reduces GPU performance because
5532 // the CPU is too busy to handle GPU synchronization
5534 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5537 return device_types_filter
;
5540 u32
get_random_num (const u32 min
, const u32 max
)
5542 if (min
== max
) return (min
);
5544 return ((rand () % (max
- min
)) + min
);
5547 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5549 u32 quotient
= dividend
/ divisor
;
5551 if (dividend
% divisor
) quotient
++;
5556 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5558 u64 quotient
= dividend
/ divisor
;
5560 if (dividend
% divisor
) quotient
++;
5565 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5567 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5568 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5570 if (tm
->tm_year
- 70)
5572 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5573 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5575 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5577 else if (tm
->tm_yday
)
5579 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5580 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5582 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5584 else if (tm
->tm_hour
)
5586 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5587 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5589 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5591 else if (tm
->tm_min
)
5593 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5594 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5596 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5600 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5602 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5606 void format_speed_display (float val
, char *buf
, size_t len
)
5617 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5628 /* generate output */
5632 snprintf (buf
, len
- 1, "%.0f ", val
);
5636 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5640 void lowercase (u8
*buf
, int len
)
5642 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5645 void uppercase (u8
*buf
, int len
)
5647 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5650 int fgetl (FILE *fp
, char *line_buf
)
5656 const int c
= fgetc (fp
);
5658 if (c
== EOF
) break;
5660 line_buf
[line_len
] = (char) c
;
5664 if (line_len
== HCBUFSIZ
) line_len
--;
5666 if (c
== '\n') break;
5669 if (line_len
== 0) return 0;
5671 if (line_buf
[line_len
- 1] == '\n')
5675 line_buf
[line_len
] = 0;
5678 if (line_len
== 0) return 0;
5680 if (line_buf
[line_len
- 1] == '\r')
5684 line_buf
[line_len
] = 0;
5690 int in_superchop (char *buf
)
5692 int len
= strlen (buf
);
5696 if (buf
[len
- 1] == '\n')
5703 if (buf
[len
- 1] == '\r')
5718 char **scan_directory (const char *path
)
5720 char *tmp_path
= mystrdup (path
);
5722 size_t tmp_path_len
= strlen (tmp_path
);
5724 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5726 tmp_path
[tmp_path_len
- 1] = 0;
5728 tmp_path_len
= strlen (tmp_path
);
5731 char **files
= NULL
;
5737 if ((d
= opendir (tmp_path
)) != NULL
)
5743 memset (&e
, 0, sizeof (e
));
5744 struct dirent
*de
= NULL
;
5746 if (readdir_r (d
, &e
, &de
) != 0)
5748 log_error ("ERROR: readdir_r() failed");
5753 if (de
== NULL
) break;
5757 while ((de
= readdir (d
)) != NULL
)
5760 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5762 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5764 char *path_file
= (char *) mymalloc (path_size
+ 1);
5766 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5768 path_file
[path_size
] = 0;
5772 if ((d_test
= opendir (path_file
)) != NULL
)
5780 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5784 files
[num_files
- 1] = path_file
;
5790 else if (errno
== ENOTDIR
)
5792 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5796 files
[num_files
- 1] = mystrdup (path
);
5799 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5803 files
[num_files
- 1] = NULL
;
5810 int count_dictionaries (char **dictionary_files
)
5812 if (dictionary_files
== NULL
) return 0;
5816 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5824 char *stroptitype (const uint opti_type
)
5828 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5829 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5830 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5831 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5832 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5833 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5834 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5835 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5836 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5837 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5838 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5839 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5840 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5841 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5842 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5843 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5844 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5845 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5846 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5852 char *strparser (const uint parser_status
)
5854 switch (parser_status
)
5856 case PARSER_OK
: return ((char *) PA_000
); break;
5857 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5858 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5859 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5860 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5861 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5862 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5863 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5864 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5865 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5866 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5867 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5868 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5869 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5870 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5871 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5872 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5875 return ((char *) PA_255
);
5878 char *strhashtype (const uint hash_mode
)
5882 case 0: return ((char *) HT_00000
); break;
5883 case 10: return ((char *) HT_00010
); break;
5884 case 11: return ((char *) HT_00011
); break;
5885 case 12: return ((char *) HT_00012
); break;
5886 case 20: return ((char *) HT_00020
); break;
5887 case 21: return ((char *) HT_00021
); break;
5888 case 22: return ((char *) HT_00022
); break;
5889 case 23: return ((char *) HT_00023
); break;
5890 case 30: return ((char *) HT_00030
); break;
5891 case 40: return ((char *) HT_00040
); break;
5892 case 50: return ((char *) HT_00050
); break;
5893 case 60: return ((char *) HT_00060
); break;
5894 case 100: return ((char *) HT_00100
); break;
5895 case 101: return ((char *) HT_00101
); break;
5896 case 110: return ((char *) HT_00110
); break;
5897 case 111: return ((char *) HT_00111
); break;
5898 case 112: return ((char *) HT_00112
); break;
5899 case 120: return ((char *) HT_00120
); break;
5900 case 121: return ((char *) HT_00121
); break;
5901 case 122: return ((char *) HT_00122
); break;
5902 case 124: return ((char *) HT_00124
); break;
5903 case 125: return ((char *) HT_00125
); break;
5904 case 130: return ((char *) HT_00130
); break;
5905 case 131: return ((char *) HT_00131
); break;
5906 case 132: return ((char *) HT_00132
); break;
5907 case 133: return ((char *) HT_00133
); break;
5908 case 140: return ((char *) HT_00140
); break;
5909 case 141: return ((char *) HT_00141
); break;
5910 case 150: return ((char *) HT_00150
); break;
5911 case 160: return ((char *) HT_00160
); break;
5912 case 200: return ((char *) HT_00200
); break;
5913 case 300: return ((char *) HT_00300
); break;
5914 case 400: return ((char *) HT_00400
); break;
5915 case 500: return ((char *) HT_00500
); break;
5916 case 501: return ((char *) HT_00501
); break;
5917 case 900: return ((char *) HT_00900
); break;
5918 case 910: return ((char *) HT_00910
); break;
5919 case 1000: return ((char *) HT_01000
); break;
5920 case 1100: return ((char *) HT_01100
); break;
5921 case 1400: return ((char *) HT_01400
); break;
5922 case 1410: return ((char *) HT_01410
); break;
5923 case 1420: return ((char *) HT_01420
); break;
5924 case 1421: return ((char *) HT_01421
); break;
5925 case 1430: return ((char *) HT_01430
); break;
5926 case 1440: return ((char *) HT_01440
); break;
5927 case 1441: return ((char *) HT_01441
); break;
5928 case 1450: return ((char *) HT_01450
); break;
5929 case 1460: return ((char *) HT_01460
); break;
5930 case 1500: return ((char *) HT_01500
); break;
5931 case 1600: return ((char *) HT_01600
); break;
5932 case 1700: return ((char *) HT_01700
); break;
5933 case 1710: return ((char *) HT_01710
); break;
5934 case 1711: return ((char *) HT_01711
); break;
5935 case 1720: return ((char *) HT_01720
); break;
5936 case 1722: return ((char *) HT_01722
); break;
5937 case 1730: return ((char *) HT_01730
); break;
5938 case 1731: return ((char *) HT_01731
); break;
5939 case 1740: return ((char *) HT_01740
); break;
5940 case 1750: return ((char *) HT_01750
); break;
5941 case 1760: return ((char *) HT_01760
); break;
5942 case 1800: return ((char *) HT_01800
); break;
5943 case 2100: return ((char *) HT_02100
); break;
5944 case 2400: return ((char *) HT_02400
); break;
5945 case 2410: return ((char *) HT_02410
); break;
5946 case 2500: return ((char *) HT_02500
); break;
5947 case 2600: return ((char *) HT_02600
); break;
5948 case 2611: return ((char *) HT_02611
); break;
5949 case 2612: return ((char *) HT_02612
); break;
5950 case 2711: return ((char *) HT_02711
); break;
5951 case 2811: return ((char *) HT_02811
); break;
5952 case 3000: return ((char *) HT_03000
); break;
5953 case 3100: return ((char *) HT_03100
); break;
5954 case 3200: return ((char *) HT_03200
); break;
5955 case 3710: return ((char *) HT_03710
); break;
5956 case 3711: return ((char *) HT_03711
); break;
5957 case 3800: return ((char *) HT_03800
); break;
5958 case 4300: return ((char *) HT_04300
); break;
5959 case 4400: return ((char *) HT_04400
); break;
5960 case 4500: return ((char *) HT_04500
); break;
5961 case 4700: return ((char *) HT_04700
); break;
5962 case 4800: return ((char *) HT_04800
); break;
5963 case 4900: return ((char *) HT_04900
); break;
5964 case 5000: return ((char *) HT_05000
); break;
5965 case 5100: return ((char *) HT_05100
); break;
5966 case 5200: return ((char *) HT_05200
); break;
5967 case 5300: return ((char *) HT_05300
); break;
5968 case 5400: return ((char *) HT_05400
); break;
5969 case 5500: return ((char *) HT_05500
); break;
5970 case 5600: return ((char *) HT_05600
); break;
5971 case 5700: return ((char *) HT_05700
); break;
5972 case 5800: return ((char *) HT_05800
); break;
5973 case 6000: return ((char *) HT_06000
); break;
5974 case 6100: return ((char *) HT_06100
); break;
5975 case 6211: return ((char *) HT_06211
); break;
5976 case 6212: return ((char *) HT_06212
); break;
5977 case 6213: return ((char *) HT_06213
); break;
5978 case 6221: return ((char *) HT_06221
); break;
5979 case 6222: return ((char *) HT_06222
); break;
5980 case 6223: return ((char *) HT_06223
); break;
5981 case 6231: return ((char *) HT_06231
); break;
5982 case 6232: return ((char *) HT_06232
); break;
5983 case 6233: return ((char *) HT_06233
); break;
5984 case 6241: return ((char *) HT_06241
); break;
5985 case 6242: return ((char *) HT_06242
); break;
5986 case 6243: return ((char *) HT_06243
); break;
5987 case 6300: return ((char *) HT_06300
); break;
5988 case 6400: return ((char *) HT_06400
); break;
5989 case 6500: return ((char *) HT_06500
); break;
5990 case 6600: return ((char *) HT_06600
); break;
5991 case 6700: return ((char *) HT_06700
); break;
5992 case 6800: return ((char *) HT_06800
); break;
5993 case 6900: return ((char *) HT_06900
); break;
5994 case 7100: return ((char *) HT_07100
); break;
5995 case 7200: return ((char *) HT_07200
); break;
5996 case 7300: return ((char *) HT_07300
); break;
5997 case 7400: return ((char *) HT_07400
); break;
5998 case 7500: return ((char *) HT_07500
); break;
5999 case 7600: return ((char *) HT_07600
); break;
6000 case 7700: return ((char *) HT_07700
); break;
6001 case 7800: return ((char *) HT_07800
); break;
6002 case 7900: return ((char *) HT_07900
); break;
6003 case 8000: return ((char *) HT_08000
); break;
6004 case 8100: return ((char *) HT_08100
); break;
6005 case 8200: return ((char *) HT_08200
); break;
6006 case 8300: return ((char *) HT_08300
); break;
6007 case 8400: return ((char *) HT_08400
); break;
6008 case 8500: return ((char *) HT_08500
); break;
6009 case 8600: return ((char *) HT_08600
); break;
6010 case 8700: return ((char *) HT_08700
); break;
6011 case 8800: return ((char *) HT_08800
); break;
6012 case 8900: return ((char *) HT_08900
); break;
6013 case 9000: return ((char *) HT_09000
); break;
6014 case 9100: return ((char *) HT_09100
); break;
6015 case 9200: return ((char *) HT_09200
); break;
6016 case 9300: return ((char *) HT_09300
); break;
6017 case 9400: return ((char *) HT_09400
); break;
6018 case 9500: return ((char *) HT_09500
); break;
6019 case 9600: return ((char *) HT_09600
); break;
6020 case 9700: return ((char *) HT_09700
); break;
6021 case 9710: return ((char *) HT_09710
); break;
6022 case 9720: return ((char *) HT_09720
); break;
6023 case 9800: return ((char *) HT_09800
); break;
6024 case 9810: return ((char *) HT_09810
); break;
6025 case 9820: return ((char *) HT_09820
); break;
6026 case 9900: return ((char *) HT_09900
); break;
6027 case 10000: return ((char *) HT_10000
); break;
6028 case 10100: return ((char *) HT_10100
); break;
6029 case 10200: return ((char *) HT_10200
); break;
6030 case 10300: return ((char *) HT_10300
); break;
6031 case 10400: return ((char *) HT_10400
); break;
6032 case 10410: return ((char *) HT_10410
); break;
6033 case 10420: return ((char *) HT_10420
); break;
6034 case 10500: return ((char *) HT_10500
); break;
6035 case 10600: return ((char *) HT_10600
); break;
6036 case 10700: return ((char *) HT_10700
); break;
6037 case 10800: return ((char *) HT_10800
); break;
6038 case 10900: return ((char *) HT_10900
); break;
6039 case 11000: return ((char *) HT_11000
); break;
6040 case 11100: return ((char *) HT_11100
); break;
6041 case 11200: return ((char *) HT_11200
); break;
6042 case 11300: return ((char *) HT_11300
); break;
6043 case 11400: return ((char *) HT_11400
); break;
6044 case 11500: return ((char *) HT_11500
); break;
6045 case 11600: return ((char *) HT_11600
); break;
6046 case 11700: return ((char *) HT_11700
); break;
6047 case 11800: return ((char *) HT_11800
); break;
6048 case 11900: return ((char *) HT_11900
); break;
6049 case 12000: return ((char *) HT_12000
); break;
6050 case 12100: return ((char *) HT_12100
); break;
6051 case 12200: return ((char *) HT_12200
); break;
6052 case 12300: return ((char *) HT_12300
); break;
6053 case 12400: return ((char *) HT_12400
); break;
6054 case 12500: return ((char *) HT_12500
); break;
6055 case 12600: return ((char *) HT_12600
); break;
6056 case 12700: return ((char *) HT_12700
); break;
6057 case 12800: return ((char *) HT_12800
); break;
6058 case 12900: return ((char *) HT_12900
); break;
6059 case 13000: return ((char *) HT_13000
); break;
6060 case 13100: return ((char *) HT_13100
); break;
6061 case 13200: return ((char *) HT_13200
); break;
6062 case 13300: return ((char *) HT_13300
); break;
6063 case 13400: return ((char *) HT_13400
); break;
6064 case 13500: return ((char *) HT_13500
); break;
6065 case 13600: return ((char *) HT_13600
); break;
6066 case 13711: return ((char *) HT_13711
); break;
6067 case 13712: return ((char *) HT_13712
); break;
6068 case 13713: return ((char *) HT_13713
); break;
6069 case 13721: return ((char *) HT_13721
); break;
6070 case 13722: return ((char *) HT_13722
); break;
6071 case 13723: return ((char *) HT_13723
); break;
6072 case 13731: return ((char *) HT_13731
); break;
6073 case 13732: return ((char *) HT_13732
); break;
6074 case 13733: return ((char *) HT_13733
); break;
6075 case 13741: return ((char *) HT_13741
); break;
6076 case 13742: return ((char *) HT_13742
); break;
6077 case 13743: return ((char *) HT_13743
); break;
6078 case 13751: return ((char *) HT_13751
); break;
6079 case 13752: return ((char *) HT_13752
); break;
6080 case 13753: return ((char *) HT_13753
); break;
6081 case 13761: return ((char *) HT_13761
); break;
6082 case 13762: return ((char *) HT_13762
); break;
6083 case 13763: return ((char *) HT_13763
); break;
6084 case 13800: return ((char *) HT_13800
); break;
6087 return ((char *) "Unknown");
6090 char *strstatus (const uint devices_status
)
6092 switch (devices_status
)
6094 case STATUS_INIT
: return ((char *) ST_0000
); break;
6095 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6096 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6097 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6098 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6099 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6100 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6101 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6102 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6103 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6104 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6107 return ((char *) "Unknown");
6110 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6112 uint hash_type
= data
.hash_type
;
6113 uint hash_mode
= data
.hash_mode
;
6114 uint salt_type
= data
.salt_type
;
6115 uint opts_type
= data
.opts_type
;
6116 uint opti_type
= data
.opti_type
;
6117 uint dgst_size
= data
.dgst_size
;
6119 char *hashfile
= data
.hashfile
;
6123 uint digest_buf
[64] = { 0 };
6125 u64
*digest_buf64
= (u64
*) digest_buf
;
6127 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6129 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6131 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6137 case HASH_TYPE_DESCRYPT
:
6138 FP (digest_buf
[1], digest_buf
[0], tt
);
6141 case HASH_TYPE_DESRACF
:
6142 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6143 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6145 FP (digest_buf
[1], digest_buf
[0], tt
);
6149 FP (digest_buf
[1], digest_buf
[0], tt
);
6152 case HASH_TYPE_NETNTLM
:
6153 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6154 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6155 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6156 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6158 FP (digest_buf
[1], digest_buf
[0], tt
);
6159 FP (digest_buf
[3], digest_buf
[2], tt
);
6162 case HASH_TYPE_BSDICRYPT
:
6163 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6164 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6166 FP (digest_buf
[1], digest_buf
[0], tt
);
6171 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6176 digest_buf
[0] += MD4M_A
;
6177 digest_buf
[1] += MD4M_B
;
6178 digest_buf
[2] += MD4M_C
;
6179 digest_buf
[3] += MD4M_D
;
6183 digest_buf
[0] += MD5M_A
;
6184 digest_buf
[1] += MD5M_B
;
6185 digest_buf
[2] += MD5M_C
;
6186 digest_buf
[3] += MD5M_D
;
6189 case HASH_TYPE_SHA1
:
6190 digest_buf
[0] += SHA1M_A
;
6191 digest_buf
[1] += SHA1M_B
;
6192 digest_buf
[2] += SHA1M_C
;
6193 digest_buf
[3] += SHA1M_D
;
6194 digest_buf
[4] += SHA1M_E
;
6197 case HASH_TYPE_SHA256
:
6198 digest_buf
[0] += SHA256M_A
;
6199 digest_buf
[1] += SHA256M_B
;
6200 digest_buf
[2] += SHA256M_C
;
6201 digest_buf
[3] += SHA256M_D
;
6202 digest_buf
[4] += SHA256M_E
;
6203 digest_buf
[5] += SHA256M_F
;
6204 digest_buf
[6] += SHA256M_G
;
6205 digest_buf
[7] += SHA256M_H
;
6208 case HASH_TYPE_SHA384
:
6209 digest_buf64
[0] += SHA384M_A
;
6210 digest_buf64
[1] += SHA384M_B
;
6211 digest_buf64
[2] += SHA384M_C
;
6212 digest_buf64
[3] += SHA384M_D
;
6213 digest_buf64
[4] += SHA384M_E
;
6214 digest_buf64
[5] += SHA384M_F
;
6215 digest_buf64
[6] += 0;
6216 digest_buf64
[7] += 0;
6219 case HASH_TYPE_SHA512
:
6220 digest_buf64
[0] += SHA512M_A
;
6221 digest_buf64
[1] += SHA512M_B
;
6222 digest_buf64
[2] += SHA512M_C
;
6223 digest_buf64
[3] += SHA512M_D
;
6224 digest_buf64
[4] += SHA512M_E
;
6225 digest_buf64
[5] += SHA512M_F
;
6226 digest_buf64
[6] += SHA512M_G
;
6227 digest_buf64
[7] += SHA512M_H
;
6232 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6234 if (dgst_size
== DGST_SIZE_4_2
)
6236 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6238 else if (dgst_size
== DGST_SIZE_4_4
)
6240 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6242 else if (dgst_size
== DGST_SIZE_4_5
)
6244 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6246 else if (dgst_size
== DGST_SIZE_4_6
)
6248 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6250 else if (dgst_size
== DGST_SIZE_4_8
)
6252 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6254 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6256 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6258 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6260 else if (hash_type
== HASH_TYPE_SHA384
)
6262 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6264 else if (hash_type
== HASH_TYPE_SHA512
)
6266 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6268 else if (hash_type
== HASH_TYPE_GOST
)
6270 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6273 else if (dgst_size
== DGST_SIZE_4_64
)
6275 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6277 else if (dgst_size
== DGST_SIZE_8_25
)
6279 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6283 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6284 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6285 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6291 memset (&salt
, 0, sizeof (salt_t
));
6293 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6295 char *ptr
= (char *) salt
.salt_buf
;
6297 uint len
= salt
.salt_len
;
6299 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6305 case HASH_TYPE_NETNTLM
:
6307 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6308 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6310 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6316 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6318 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6326 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6328 uint max
= salt
.salt_len
/ 4;
6332 for (uint i
= 0; i
< max
; i
++)
6334 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6338 if (opts_type
& OPTS_TYPE_ST_HEX
)
6340 char tmp
[64] = { 0 };
6342 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6344 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6349 memcpy (ptr
, tmp
, len
);
6352 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6354 memset (ptr
+ len
, 0, memset_size
);
6356 salt
.salt_len
= len
;
6360 // some modes require special encoding
6363 uint out_buf_plain
[256] = { 0 };
6364 uint out_buf_salt
[256] = { 0 };
6366 char tmp_buf
[1024] = { 0 };
6368 char *ptr_plain
= (char *) out_buf_plain
;
6369 char *ptr_salt
= (char *) out_buf_salt
;
6371 if (hash_mode
== 22)
6373 char username
[30] = { 0 };
6375 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6377 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6379 u16
*ptr
= (u16
*) digest_buf
;
6381 tmp_buf
[ 0] = sig
[0];
6382 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6383 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6384 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6385 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6386 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6387 tmp_buf
[ 6] = sig
[1];
6388 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6389 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6390 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6391 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6392 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6393 tmp_buf
[12] = sig
[2];
6394 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6395 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6396 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6397 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6398 tmp_buf
[17] = sig
[3];
6399 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6400 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6401 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6402 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6403 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6404 tmp_buf
[23] = sig
[4];
6405 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6406 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6407 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6408 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6409 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6410 tmp_buf
[29] = sig
[5];
6412 snprintf (out_buf
, len
-1, "%s:%s",
6416 else if (hash_mode
== 23)
6418 // do not show the skyper part in output
6420 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6422 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6424 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6431 else if (hash_mode
== 101)
6433 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6435 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6436 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6437 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6438 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6439 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6441 memcpy (tmp_buf
, digest_buf
, 20);
6443 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6445 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6447 else if (hash_mode
== 111)
6449 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6451 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6452 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6453 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6454 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6455 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6457 memcpy (tmp_buf
, digest_buf
, 20);
6458 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6460 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6462 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6464 else if ((hash_mode
== 122) || (hash_mode
== 125))
6466 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6467 (char *) salt
.salt_buf
,
6474 else if (hash_mode
== 124)
6476 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6477 (char *) salt
.salt_buf
,
6484 else if (hash_mode
== 131)
6486 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6487 (char *) salt
.salt_buf
,
6495 else if (hash_mode
== 132)
6497 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6498 (char *) salt
.salt_buf
,
6505 else if (hash_mode
== 133)
6507 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6509 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6510 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6511 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6512 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6513 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6515 memcpy (tmp_buf
, digest_buf
, 20);
6517 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6519 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6521 else if (hash_mode
== 141)
6523 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6525 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6527 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6529 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6531 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6532 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6533 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6534 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6535 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6537 memcpy (tmp_buf
, digest_buf
, 20);
6539 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6543 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6545 else if (hash_mode
== 400)
6547 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6549 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6550 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6551 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6552 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6554 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6556 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6558 else if (hash_mode
== 500)
6560 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6562 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6563 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6564 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6565 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6567 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6569 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6571 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6575 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6578 else if (hash_mode
== 501)
6580 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6582 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6583 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6585 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6587 else if (hash_mode
== 1421)
6589 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6591 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6607 else if (hash_mode
== 1441)
6609 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6611 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6613 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6615 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6617 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6618 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6619 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6620 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6621 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6622 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6623 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6624 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6626 memcpy (tmp_buf
, digest_buf
, 32);
6628 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6632 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6634 else if (hash_mode
== 1500)
6636 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6637 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6638 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6639 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6640 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6642 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6644 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6646 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6647 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6649 memcpy (tmp_buf
, digest_buf
, 8);
6651 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6653 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6657 else if (hash_mode
== 1600)
6659 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6661 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6662 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6663 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6664 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6666 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6668 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6670 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6674 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6677 else if (hash_mode
== 1711)
6679 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6681 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6682 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6683 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6684 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6685 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6686 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6687 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6688 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6690 memcpy (tmp_buf
, digest_buf
, 64);
6691 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6693 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6695 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6697 else if (hash_mode
== 1722)
6699 uint
*ptr
= digest_buf
;
6701 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6702 (unsigned char *) salt
.salt_buf
,
6712 else if (hash_mode
== 1731)
6714 uint
*ptr
= digest_buf
;
6716 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6717 (unsigned char *) salt
.salt_buf
,
6727 else if (hash_mode
== 1800)
6731 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6732 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6733 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6734 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6735 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6736 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6737 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6738 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6740 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6742 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6744 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6748 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6751 else if (hash_mode
== 2100)
6755 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6757 salt
.salt_iter
+ 1);
6759 uint signature_len
= strlen (out_buf
);
6761 pos
+= signature_len
;
6762 len
-= signature_len
;
6764 char *salt_ptr
= (char *) salt
.salt_buf
;
6766 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6768 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6769 byte_swap_32 (digest_buf
[0]),
6770 byte_swap_32 (digest_buf
[1]),
6771 byte_swap_32 (digest_buf
[2]),
6772 byte_swap_32 (digest_buf
[3]));
6774 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6776 memcpy (tmp_buf
, digest_buf
, 16);
6778 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6780 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6781 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6782 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6783 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6785 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6786 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6787 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6788 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6790 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6791 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6792 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6793 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6795 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6796 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6797 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6798 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6800 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6801 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6802 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6803 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6807 else if (hash_mode
== 2500)
6809 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6811 wpa_t
*wpa
= &wpas
[salt_pos
];
6813 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6814 (char *) salt
.salt_buf
,
6828 else if (hash_mode
== 4400)
6830 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6831 byte_swap_32 (digest_buf
[0]),
6832 byte_swap_32 (digest_buf
[1]),
6833 byte_swap_32 (digest_buf
[2]),
6834 byte_swap_32 (digest_buf
[3]));
6836 else if (hash_mode
== 4700)
6838 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6839 byte_swap_32 (digest_buf
[0]),
6840 byte_swap_32 (digest_buf
[1]),
6841 byte_swap_32 (digest_buf
[2]),
6842 byte_swap_32 (digest_buf
[3]),
6843 byte_swap_32 (digest_buf
[4]));
6845 else if (hash_mode
== 4800)
6847 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6849 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6854 byte_swap_32 (salt
.salt_buf
[0]),
6855 byte_swap_32 (salt
.salt_buf
[1]),
6856 byte_swap_32 (salt
.salt_buf
[2]),
6857 byte_swap_32 (salt
.salt_buf
[3]),
6860 else if (hash_mode
== 4900)
6862 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6863 byte_swap_32 (digest_buf
[0]),
6864 byte_swap_32 (digest_buf
[1]),
6865 byte_swap_32 (digest_buf
[2]),
6866 byte_swap_32 (digest_buf
[3]),
6867 byte_swap_32 (digest_buf
[4]));
6869 else if (hash_mode
== 5100)
6871 snprintf (out_buf
, len
-1, "%08x%08x",
6875 else if (hash_mode
== 5200)
6877 snprintf (out_buf
, len
-1, "%s", hashfile
);
6879 else if (hash_mode
== 5300)
6881 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6883 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6885 int buf_len
= len
-1;
6889 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6891 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6893 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6895 snprintf (out_buf
, buf_len
, ":");
6901 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6909 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6911 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6913 if ((i
== 0) || (i
== 5))
6915 snprintf (out_buf
, buf_len
, ":");
6921 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6929 for (uint i
= 0; i
< 4; i
++)
6933 snprintf (out_buf
, buf_len
, ":");
6939 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6945 else if (hash_mode
== 5400)
6947 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6949 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6951 int buf_len
= len
-1;
6955 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6957 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6959 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6961 snprintf (out_buf
, buf_len
, ":");
6967 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6975 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6977 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6979 if ((i
== 0) || (i
== 5))
6981 snprintf (out_buf
, buf_len
, ":");
6987 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6995 for (uint i
= 0; i
< 5; i
++)
6999 snprintf (out_buf
, buf_len
, ":");
7005 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7011 else if (hash_mode
== 5500)
7013 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7015 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7017 char user_buf
[64] = { 0 };
7018 char domain_buf
[64] = { 0 };
7019 char srvchall_buf
[1024] = { 0 };
7020 char clichall_buf
[1024] = { 0 };
7022 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7024 char *ptr
= (char *) netntlm
->userdomain_buf
;
7026 user_buf
[i
] = ptr
[j
];
7029 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7031 char *ptr
= (char *) netntlm
->userdomain_buf
;
7033 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7036 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7038 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7040 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7043 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7045 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7047 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7050 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7058 byte_swap_32 (salt
.salt_buf_pc
[0]),
7059 byte_swap_32 (salt
.salt_buf_pc
[1]),
7062 else if (hash_mode
== 5600)
7064 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7066 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7068 char user_buf
[64] = { 0 };
7069 char domain_buf
[64] = { 0 };
7070 char srvchall_buf
[1024] = { 0 };
7071 char clichall_buf
[1024] = { 0 };
7073 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7075 char *ptr
= (char *) netntlm
->userdomain_buf
;
7077 user_buf
[i
] = ptr
[j
];
7080 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7082 char *ptr
= (char *) netntlm
->userdomain_buf
;
7084 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7087 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7089 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7091 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7094 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7096 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7098 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7101 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7111 else if (hash_mode
== 5700)
7113 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7115 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7116 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7117 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7118 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7119 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7120 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7121 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7122 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7124 memcpy (tmp_buf
, digest_buf
, 32);
7126 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7130 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7132 else if (hash_mode
== 5800)
7134 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7135 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7136 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7137 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7138 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7140 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7147 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7149 snprintf (out_buf
, len
-1, "%s", hashfile
);
7151 else if (hash_mode
== 6300)
7153 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7155 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7156 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7157 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7158 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7160 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7162 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7164 else if (hash_mode
== 6400)
7166 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7168 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7170 else if (hash_mode
== 6500)
7172 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7174 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7176 else if (hash_mode
== 6600)
7178 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7180 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7182 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7183 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7185 uint buf_len
= len
- 1;
7187 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7190 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7192 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7197 else if (hash_mode
== 6700)
7199 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7201 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7203 else if (hash_mode
== 6800)
7205 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7207 else if (hash_mode
== 7100)
7209 uint
*ptr
= digest_buf
;
7211 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7213 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7215 uint esalt
[8] = { 0 };
7217 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7218 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7219 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7220 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7221 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7222 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7223 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7224 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7226 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",
7227 SIGNATURE_SHA512OSX
,
7229 esalt
[ 0], esalt
[ 1],
7230 esalt
[ 2], esalt
[ 3],
7231 esalt
[ 4], esalt
[ 5],
7232 esalt
[ 6], esalt
[ 7],
7240 ptr
[15], ptr
[14]);
7242 else if (hash_mode
== 7200)
7244 uint
*ptr
= digest_buf
;
7246 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7248 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7252 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7254 len_used
= strlen (out_buf
);
7256 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7258 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7260 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7263 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",
7271 ptr
[15], ptr
[14]);
7273 else if (hash_mode
== 7300)
7275 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7277 rakp_t
*rakp
= &rakps
[salt_pos
];
7279 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7281 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7284 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7291 else if (hash_mode
== 7400)
7293 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7295 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7296 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7297 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7298 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7299 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7300 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7301 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7302 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7304 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7306 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7308 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7312 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7315 else if (hash_mode
== 7500)
7317 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7319 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7321 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7322 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7324 char data
[128] = { 0 };
7326 char *ptr_data
= data
;
7328 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7330 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7333 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7335 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7340 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7342 (char *) krb5pa
->user
,
7343 (char *) krb5pa
->realm
,
7344 (char *) krb5pa
->salt
,
7347 else if (hash_mode
== 7700)
7349 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7350 (char *) salt
.salt_buf
,
7354 else if (hash_mode
== 7800)
7356 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7357 (char *) salt
.salt_buf
,
7364 else if (hash_mode
== 7900)
7366 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7370 char *tmp
= (char *) salt
.salt_buf_pc
;
7372 ptr_plain
[42] = tmp
[0];
7378 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7380 else if (hash_mode
== 8000)
7382 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7383 (unsigned char *) salt
.salt_buf
,
7393 else if (hash_mode
== 8100)
7395 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7396 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7398 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7399 (unsigned char *) salt
.salt_buf
,
7406 else if (hash_mode
== 8200)
7408 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7410 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7412 char data_buf
[4096] = { 0 };
7414 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7416 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7419 data_buf
[cloudkey
->data_len
* 2] = 0;
7421 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7422 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7423 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7424 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7425 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7426 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7427 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7428 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7430 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7431 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7432 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7433 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7435 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7451 else if (hash_mode
== 8300)
7453 char digest_buf_c
[34] = { 0 };
7455 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7456 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7457 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7458 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7459 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7461 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7463 digest_buf_c
[32] = 0;
7467 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7469 char domain_buf_c
[33] = { 0 };
7471 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7473 for (uint i
= 0; i
< salt_pc_len
; i
++)
7475 const char next
= domain_buf_c
[i
];
7477 domain_buf_c
[i
] = '.';
7482 domain_buf_c
[salt_pc_len
] = 0;
7486 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7488 else if (hash_mode
== 8500)
7490 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7492 else if (hash_mode
== 2612)
7494 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7496 (char *) salt
.salt_buf
,
7502 else if (hash_mode
== 3711)
7504 char *salt_ptr
= (char *) salt
.salt_buf
;
7506 salt_ptr
[salt
.salt_len
- 1] = 0;
7508 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7509 SIGNATURE_MEDIAWIKI_B
,
7516 else if (hash_mode
== 8800)
7518 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7520 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7522 char tmp
[3073] = { 0 };
7524 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7526 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7531 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7532 SIGNATURE_ANDROIDFDE
,
7533 byte_swap_32 (salt
.salt_buf
[0]),
7534 byte_swap_32 (salt
.salt_buf
[1]),
7535 byte_swap_32 (salt
.salt_buf
[2]),
7536 byte_swap_32 (salt
.salt_buf
[3]),
7537 byte_swap_32 (digest_buf
[0]),
7538 byte_swap_32 (digest_buf
[1]),
7539 byte_swap_32 (digest_buf
[2]),
7540 byte_swap_32 (digest_buf
[3]),
7543 else if (hash_mode
== 8900)
7545 uint N
= salt
.scrypt_N
;
7546 uint r
= salt
.scrypt_r
;
7547 uint p
= salt
.scrypt_p
;
7549 char base64_salt
[32] = { 0 };
7551 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7553 memset (tmp_buf
, 0, 46);
7555 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7556 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7557 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7558 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7559 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7560 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7561 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7562 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7563 digest_buf
[8] = 0; // needed for base64_encode ()
7565 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7567 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7575 else if (hash_mode
== 9000)
7577 snprintf (out_buf
, len
-1, "%s", hashfile
);
7579 else if (hash_mode
== 9200)
7583 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7585 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7587 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7591 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7592 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7593 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7594 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7595 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7596 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7597 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7598 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7599 digest_buf
[8] = 0; // needed for base64_encode ()
7601 char tmp_buf
[64] = { 0 };
7603 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7604 tmp_buf
[43] = 0; // cut it here
7608 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7610 else if (hash_mode
== 9300)
7612 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7613 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7614 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7615 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7616 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7617 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7618 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7619 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7620 digest_buf
[8] = 0; // needed for base64_encode ()
7622 char tmp_buf
[64] = { 0 };
7624 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7625 tmp_buf
[43] = 0; // cut it here
7627 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7629 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7631 else if (hash_mode
== 9400)
7633 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7635 office2007_t
*office2007
= &office2007s
[salt_pos
];
7637 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7638 SIGNATURE_OFFICE2007
,
7641 office2007
->keySize
,
7647 office2007
->encryptedVerifier
[0],
7648 office2007
->encryptedVerifier
[1],
7649 office2007
->encryptedVerifier
[2],
7650 office2007
->encryptedVerifier
[3],
7651 office2007
->encryptedVerifierHash
[0],
7652 office2007
->encryptedVerifierHash
[1],
7653 office2007
->encryptedVerifierHash
[2],
7654 office2007
->encryptedVerifierHash
[3],
7655 office2007
->encryptedVerifierHash
[4]);
7657 else if (hash_mode
== 9500)
7659 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7661 office2010_t
*office2010
= &office2010s
[salt_pos
];
7663 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,
7669 office2010
->encryptedVerifier
[0],
7670 office2010
->encryptedVerifier
[1],
7671 office2010
->encryptedVerifier
[2],
7672 office2010
->encryptedVerifier
[3],
7673 office2010
->encryptedVerifierHash
[0],
7674 office2010
->encryptedVerifierHash
[1],
7675 office2010
->encryptedVerifierHash
[2],
7676 office2010
->encryptedVerifierHash
[3],
7677 office2010
->encryptedVerifierHash
[4],
7678 office2010
->encryptedVerifierHash
[5],
7679 office2010
->encryptedVerifierHash
[6],
7680 office2010
->encryptedVerifierHash
[7]);
7682 else if (hash_mode
== 9600)
7684 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7686 office2013_t
*office2013
= &office2013s
[salt_pos
];
7688 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,
7694 office2013
->encryptedVerifier
[0],
7695 office2013
->encryptedVerifier
[1],
7696 office2013
->encryptedVerifier
[2],
7697 office2013
->encryptedVerifier
[3],
7698 office2013
->encryptedVerifierHash
[0],
7699 office2013
->encryptedVerifierHash
[1],
7700 office2013
->encryptedVerifierHash
[2],
7701 office2013
->encryptedVerifierHash
[3],
7702 office2013
->encryptedVerifierHash
[4],
7703 office2013
->encryptedVerifierHash
[5],
7704 office2013
->encryptedVerifierHash
[6],
7705 office2013
->encryptedVerifierHash
[7]);
7707 else if (hash_mode
== 9700)
7709 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7711 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7713 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7714 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7715 byte_swap_32 (salt
.salt_buf
[0]),
7716 byte_swap_32 (salt
.salt_buf
[1]),
7717 byte_swap_32 (salt
.salt_buf
[2]),
7718 byte_swap_32 (salt
.salt_buf
[3]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7721 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7722 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7723 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7724 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7725 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7726 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7728 else if (hash_mode
== 9710)
7730 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7732 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7734 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7735 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7736 byte_swap_32 (salt
.salt_buf
[0]),
7737 byte_swap_32 (salt
.salt_buf
[1]),
7738 byte_swap_32 (salt
.salt_buf
[2]),
7739 byte_swap_32 (salt
.salt_buf
[3]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7742 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7743 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7744 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7745 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7746 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7747 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7749 else if (hash_mode
== 9720)
7751 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7753 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7755 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7757 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7758 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7759 byte_swap_32 (salt
.salt_buf
[0]),
7760 byte_swap_32 (salt
.salt_buf
[1]),
7761 byte_swap_32 (salt
.salt_buf
[2]),
7762 byte_swap_32 (salt
.salt_buf
[3]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7765 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7766 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7767 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7768 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7769 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7770 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7777 else if (hash_mode
== 9800)
7779 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7781 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7783 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7784 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7789 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7792 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7793 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7794 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7795 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7796 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7797 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7799 else if (hash_mode
== 9810)
7801 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7803 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7805 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7806 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7811 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7814 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7815 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7816 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7817 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7818 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7819 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7821 else if (hash_mode
== 9820)
7823 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7825 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7827 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7829 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7830 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7835 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7838 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7839 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7840 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7841 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7842 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7843 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7850 else if (hash_mode
== 10000)
7854 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7856 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7858 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7862 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7863 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7864 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7865 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7866 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7867 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7868 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7869 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7870 digest_buf
[8] = 0; // needed for base64_encode ()
7872 char tmp_buf
[64] = { 0 };
7874 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7878 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7880 else if (hash_mode
== 10100)
7882 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7887 byte_swap_32 (salt
.salt_buf
[0]),
7888 byte_swap_32 (salt
.salt_buf
[1]),
7889 byte_swap_32 (salt
.salt_buf
[2]),
7890 byte_swap_32 (salt
.salt_buf
[3]));
7892 else if (hash_mode
== 10200)
7894 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7896 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7900 char challenge
[100] = { 0 };
7902 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7906 char tmp_buf
[100] = { 0 };
7908 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7909 (char *) cram_md5
->user
,
7915 char response
[100] = { 0 };
7917 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7919 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7921 else if (hash_mode
== 10300)
7923 char tmp_buf
[100] = { 0 };
7925 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7926 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7928 uint tmp_len
= 20 + salt
.salt_len
;
7932 char base64_encoded
[100] = { 0 };
7934 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7936 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7938 else if (hash_mode
== 10400)
7940 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7942 pdf_t
*pdf
= &pdfs
[salt_pos
];
7944 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",
7952 byte_swap_32 (pdf
->id_buf
[0]),
7953 byte_swap_32 (pdf
->id_buf
[1]),
7954 byte_swap_32 (pdf
->id_buf
[2]),
7955 byte_swap_32 (pdf
->id_buf
[3]),
7957 byte_swap_32 (pdf
->u_buf
[0]),
7958 byte_swap_32 (pdf
->u_buf
[1]),
7959 byte_swap_32 (pdf
->u_buf
[2]),
7960 byte_swap_32 (pdf
->u_buf
[3]),
7961 byte_swap_32 (pdf
->u_buf
[4]),
7962 byte_swap_32 (pdf
->u_buf
[5]),
7963 byte_swap_32 (pdf
->u_buf
[6]),
7964 byte_swap_32 (pdf
->u_buf
[7]),
7966 byte_swap_32 (pdf
->o_buf
[0]),
7967 byte_swap_32 (pdf
->o_buf
[1]),
7968 byte_swap_32 (pdf
->o_buf
[2]),
7969 byte_swap_32 (pdf
->o_buf
[3]),
7970 byte_swap_32 (pdf
->o_buf
[4]),
7971 byte_swap_32 (pdf
->o_buf
[5]),
7972 byte_swap_32 (pdf
->o_buf
[6]),
7973 byte_swap_32 (pdf
->o_buf
[7])
7976 else if (hash_mode
== 10410)
7978 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7980 pdf_t
*pdf
= &pdfs
[salt_pos
];
7982 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",
7990 byte_swap_32 (pdf
->id_buf
[0]),
7991 byte_swap_32 (pdf
->id_buf
[1]),
7992 byte_swap_32 (pdf
->id_buf
[2]),
7993 byte_swap_32 (pdf
->id_buf
[3]),
7995 byte_swap_32 (pdf
->u_buf
[0]),
7996 byte_swap_32 (pdf
->u_buf
[1]),
7997 byte_swap_32 (pdf
->u_buf
[2]),
7998 byte_swap_32 (pdf
->u_buf
[3]),
7999 byte_swap_32 (pdf
->u_buf
[4]),
8000 byte_swap_32 (pdf
->u_buf
[5]),
8001 byte_swap_32 (pdf
->u_buf
[6]),
8002 byte_swap_32 (pdf
->u_buf
[7]),
8004 byte_swap_32 (pdf
->o_buf
[0]),
8005 byte_swap_32 (pdf
->o_buf
[1]),
8006 byte_swap_32 (pdf
->o_buf
[2]),
8007 byte_swap_32 (pdf
->o_buf
[3]),
8008 byte_swap_32 (pdf
->o_buf
[4]),
8009 byte_swap_32 (pdf
->o_buf
[5]),
8010 byte_swap_32 (pdf
->o_buf
[6]),
8011 byte_swap_32 (pdf
->o_buf
[7])
8014 else if (hash_mode
== 10420)
8016 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8018 pdf_t
*pdf
= &pdfs
[salt_pos
];
8020 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8022 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",
8030 byte_swap_32 (pdf
->id_buf
[0]),
8031 byte_swap_32 (pdf
->id_buf
[1]),
8032 byte_swap_32 (pdf
->id_buf
[2]),
8033 byte_swap_32 (pdf
->id_buf
[3]),
8035 byte_swap_32 (pdf
->u_buf
[0]),
8036 byte_swap_32 (pdf
->u_buf
[1]),
8037 byte_swap_32 (pdf
->u_buf
[2]),
8038 byte_swap_32 (pdf
->u_buf
[3]),
8039 byte_swap_32 (pdf
->u_buf
[4]),
8040 byte_swap_32 (pdf
->u_buf
[5]),
8041 byte_swap_32 (pdf
->u_buf
[6]),
8042 byte_swap_32 (pdf
->u_buf
[7]),
8044 byte_swap_32 (pdf
->o_buf
[0]),
8045 byte_swap_32 (pdf
->o_buf
[1]),
8046 byte_swap_32 (pdf
->o_buf
[2]),
8047 byte_swap_32 (pdf
->o_buf
[3]),
8048 byte_swap_32 (pdf
->o_buf
[4]),
8049 byte_swap_32 (pdf
->o_buf
[5]),
8050 byte_swap_32 (pdf
->o_buf
[6]),
8051 byte_swap_32 (pdf
->o_buf
[7]),
8059 else if (hash_mode
== 10500)
8061 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8063 pdf_t
*pdf
= &pdfs
[salt_pos
];
8065 if (pdf
->id_len
== 32)
8067 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",
8075 byte_swap_32 (pdf
->id_buf
[0]),
8076 byte_swap_32 (pdf
->id_buf
[1]),
8077 byte_swap_32 (pdf
->id_buf
[2]),
8078 byte_swap_32 (pdf
->id_buf
[3]),
8079 byte_swap_32 (pdf
->id_buf
[4]),
8080 byte_swap_32 (pdf
->id_buf
[5]),
8081 byte_swap_32 (pdf
->id_buf
[6]),
8082 byte_swap_32 (pdf
->id_buf
[7]),
8084 byte_swap_32 (pdf
->u_buf
[0]),
8085 byte_swap_32 (pdf
->u_buf
[1]),
8086 byte_swap_32 (pdf
->u_buf
[2]),
8087 byte_swap_32 (pdf
->u_buf
[3]),
8088 byte_swap_32 (pdf
->u_buf
[4]),
8089 byte_swap_32 (pdf
->u_buf
[5]),
8090 byte_swap_32 (pdf
->u_buf
[6]),
8091 byte_swap_32 (pdf
->u_buf
[7]),
8093 byte_swap_32 (pdf
->o_buf
[0]),
8094 byte_swap_32 (pdf
->o_buf
[1]),
8095 byte_swap_32 (pdf
->o_buf
[2]),
8096 byte_swap_32 (pdf
->o_buf
[3]),
8097 byte_swap_32 (pdf
->o_buf
[4]),
8098 byte_swap_32 (pdf
->o_buf
[5]),
8099 byte_swap_32 (pdf
->o_buf
[6]),
8100 byte_swap_32 (pdf
->o_buf
[7])
8105 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",
8113 byte_swap_32 (pdf
->id_buf
[0]),
8114 byte_swap_32 (pdf
->id_buf
[1]),
8115 byte_swap_32 (pdf
->id_buf
[2]),
8116 byte_swap_32 (pdf
->id_buf
[3]),
8118 byte_swap_32 (pdf
->u_buf
[0]),
8119 byte_swap_32 (pdf
->u_buf
[1]),
8120 byte_swap_32 (pdf
->u_buf
[2]),
8121 byte_swap_32 (pdf
->u_buf
[3]),
8122 byte_swap_32 (pdf
->u_buf
[4]),
8123 byte_swap_32 (pdf
->u_buf
[5]),
8124 byte_swap_32 (pdf
->u_buf
[6]),
8125 byte_swap_32 (pdf
->u_buf
[7]),
8127 byte_swap_32 (pdf
->o_buf
[0]),
8128 byte_swap_32 (pdf
->o_buf
[1]),
8129 byte_swap_32 (pdf
->o_buf
[2]),
8130 byte_swap_32 (pdf
->o_buf
[3]),
8131 byte_swap_32 (pdf
->o_buf
[4]),
8132 byte_swap_32 (pdf
->o_buf
[5]),
8133 byte_swap_32 (pdf
->o_buf
[6]),
8134 byte_swap_32 (pdf
->o_buf
[7])
8138 else if (hash_mode
== 10600)
8140 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8142 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8143 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8145 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8147 else if (hash_mode
== 10700)
8149 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8151 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8152 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8154 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8156 else if (hash_mode
== 10900)
8158 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8160 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8161 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8163 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8165 else if (hash_mode
== 11100)
8167 u32 salt_challenge
= salt
.salt_buf
[0];
8169 salt_challenge
= byte_swap_32 (salt_challenge
);
8171 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8173 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8174 SIGNATURE_POSTGRESQL_AUTH
,
8182 else if (hash_mode
== 11200)
8184 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8185 SIGNATURE_MYSQL_AUTH
,
8186 (unsigned char *) salt
.salt_buf
,
8193 else if (hash_mode
== 11300)
8195 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8197 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8199 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8200 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8201 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8203 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8204 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8205 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8207 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8209 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8211 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8214 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8216 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8218 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8221 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8223 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8225 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8228 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8229 SIGNATURE_BITCOIN_WALLET
,
8233 (unsigned char *) salt
.salt_buf
,
8241 free (cry_master_buf
);
8243 free (public_key_buf
);
8245 else if (hash_mode
== 11400)
8247 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8249 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8250 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8252 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8254 else if (hash_mode
== 11600)
8256 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8258 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8260 const uint data_len
= seven_zip
->data_len
;
8262 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8264 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8266 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8268 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8271 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8272 SIGNATURE_SEVEN_ZIP
,
8276 (char *) seven_zip
->salt_buf
,
8278 seven_zip
->iv_buf
[0],
8279 seven_zip
->iv_buf
[1],
8280 seven_zip
->iv_buf
[2],
8281 seven_zip
->iv_buf
[3],
8283 seven_zip
->data_len
,
8284 seven_zip
->unpack_size
,
8289 else if (hash_mode
== 11700)
8291 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8301 else if (hash_mode
== 11800)
8303 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8321 else if (hash_mode
== 11900)
8323 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8325 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8326 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8328 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8330 else if (hash_mode
== 12000)
8332 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8334 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8335 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8337 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8339 else if (hash_mode
== 12100)
8341 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8343 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8344 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8346 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8348 else if (hash_mode
== 12200)
8350 uint
*ptr_digest
= digest_buf
;
8351 uint
*ptr_salt
= salt
.salt_buf
;
8353 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8360 else if (hash_mode
== 12300)
8362 uint
*ptr_digest
= digest_buf
;
8363 uint
*ptr_salt
= salt
.salt_buf
;
8365 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",
8366 ptr_digest
[ 0], ptr_digest
[ 1],
8367 ptr_digest
[ 2], ptr_digest
[ 3],
8368 ptr_digest
[ 4], ptr_digest
[ 5],
8369 ptr_digest
[ 6], ptr_digest
[ 7],
8370 ptr_digest
[ 8], ptr_digest
[ 9],
8371 ptr_digest
[10], ptr_digest
[11],
8372 ptr_digest
[12], ptr_digest
[13],
8373 ptr_digest
[14], ptr_digest
[15],
8379 else if (hash_mode
== 12400)
8381 // encode iteration count
8383 char salt_iter
[5] = { 0 };
8385 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8386 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8387 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8388 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8393 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8394 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8395 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8396 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8401 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8403 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8404 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8406 memcpy (tmp_buf
, digest_buf
, 8);
8408 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8412 // fill the resulting buffer
8414 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8416 else if (hash_mode
== 12500)
8418 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8420 byte_swap_32 (salt
.salt_buf
[0]),
8421 byte_swap_32 (salt
.salt_buf
[1]),
8427 else if (hash_mode
== 12600)
8429 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8430 digest_buf
[0] + salt
.salt_buf_pc
[0],
8431 digest_buf
[1] + salt
.salt_buf_pc
[1],
8432 digest_buf
[2] + salt
.salt_buf_pc
[2],
8433 digest_buf
[3] + salt
.salt_buf_pc
[3],
8434 digest_buf
[4] + salt
.salt_buf_pc
[4],
8435 digest_buf
[5] + salt
.salt_buf_pc
[5],
8436 digest_buf
[6] + salt
.salt_buf_pc
[6],
8437 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8439 else if (hash_mode
== 12700)
8441 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8443 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8444 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8446 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8448 else if (hash_mode
== 12800)
8450 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8452 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",
8465 byte_swap_32 (digest_buf
[0]),
8466 byte_swap_32 (digest_buf
[1]),
8467 byte_swap_32 (digest_buf
[2]),
8468 byte_swap_32 (digest_buf
[3]),
8469 byte_swap_32 (digest_buf
[4]),
8470 byte_swap_32 (digest_buf
[5]),
8471 byte_swap_32 (digest_buf
[6]),
8472 byte_swap_32 (digest_buf
[7])
8475 else if (hash_mode
== 12900)
8477 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",
8486 byte_swap_32 (digest_buf
[0]),
8487 byte_swap_32 (digest_buf
[1]),
8488 byte_swap_32 (digest_buf
[2]),
8489 byte_swap_32 (digest_buf
[3]),
8490 byte_swap_32 (digest_buf
[4]),
8491 byte_swap_32 (digest_buf
[5]),
8492 byte_swap_32 (digest_buf
[6]),
8493 byte_swap_32 (digest_buf
[7]),
8500 else if (hash_mode
== 13000)
8502 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8504 rar5_t
*rar5
= &rar5s
[salt_pos
];
8506 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8516 byte_swap_32 (digest_buf
[0]),
8517 byte_swap_32 (digest_buf
[1])
8520 else if (hash_mode
== 13100)
8522 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8524 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8526 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8527 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8529 char data
[2560 * 4 * 2] = { 0 };
8531 char *ptr_data
= data
;
8533 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8534 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8539 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8540 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8542 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8544 (char *) krb5tgs
->account_info
,
8548 else if (hash_mode
== 13200)
8550 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8564 else if (hash_mode
== 13300)
8566 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8567 SIGNATURE_AXCRYPT_SHA1
,
8573 else if (hash_mode
== 13400)
8575 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8577 keepass_t
*keepass
= &keepasss
[salt_pos
];
8579 u32 version
= (u32
) keepass
->version
;
8580 u32 rounds
= salt
.salt_iter
;
8581 u32 algorithm
= (u32
) keepass
->algorithm
;
8582 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8584 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8585 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8586 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8587 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8588 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8590 /* specific to version 1 */
8594 /* specific to version 2 */
8595 u32 expected_bytes_len
;
8596 u32
*ptr_expected_bytes
;
8598 u32 final_random_seed_len
;
8599 u32 transf_random_seed_len
;
8601 u32 contents_hash_len
;
8603 transf_random_seed_len
= 8;
8605 contents_hash_len
= 8;
8606 final_random_seed_len
= 8;
8609 final_random_seed_len
= 4;
8611 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8617 char *ptr_data
= out_buf
;
8619 ptr_data
+= strlen(out_buf
);
8624 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8625 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8630 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8631 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8636 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8637 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8644 contents_len
= (u32
) keepass
->contents_len
;
8645 ptr_contents
= (u32
*) keepass
->contents
;
8647 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8648 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8660 char ptr_contents_len
[10] = { 0 };
8662 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8664 sprintf (ptr_data
, "%d", contents_len
);
8666 ptr_data
+= strlen(ptr_contents_len
);
8671 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8672 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8674 else if (version
== 2)
8676 expected_bytes_len
= 8;
8677 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8679 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8680 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8685 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8686 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8700 sprintf (ptr_data
, "%d", keyfile_len
);
8707 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8708 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8711 else if (hash_mode
== 13500)
8713 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8715 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8717 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8719 char pstoken_tmp
[1024 + 1] = { 0 };
8721 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8723 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8725 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8728 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8736 else if (hash_mode
== 13600)
8738 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8740 zip2_t
*zip2
= &zip2s
[salt_pos
];
8742 const u32 salt_len
= zip2
->salt_len
;
8744 char salt_tmp
[32 + 1] = { 0 };
8746 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8748 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8750 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8753 const u32 data_len
= zip2
->data_len
;
8755 char data_tmp
[8192 + 1] = { 0 };
8757 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8759 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8761 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8764 const u32 auth_len
= zip2
->auth_len
;
8766 char auth_tmp
[20 + 1] = { 0 };
8768 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8770 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8772 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8775 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8776 SIGNATURE_ZIP2_START
,
8782 zip2
->compress_length
,
8785 SIGNATURE_ZIP2_STOP
);
8787 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8789 snprintf (out_buf
, len
-1, "%s", hashfile
);
8791 else if (hash_mode
== 13800)
8793 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8795 win8phone_t
*esalt
= &esalts
[salt_pos
];
8797 char buf
[256 + 1] = { 0 };
8799 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8801 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8804 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8817 if (hash_type
== HASH_TYPE_MD4
)
8819 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8825 else if (hash_type
== HASH_TYPE_MD5
)
8827 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8833 else if (hash_type
== HASH_TYPE_SHA1
)
8835 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8842 else if (hash_type
== HASH_TYPE_SHA256
)
8844 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8854 else if (hash_type
== HASH_TYPE_SHA384
)
8856 uint
*ptr
= digest_buf
;
8858 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8866 else if (hash_type
== HASH_TYPE_SHA512
)
8868 uint
*ptr
= digest_buf
;
8870 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8880 else if (hash_type
== HASH_TYPE_LM
)
8882 snprintf (out_buf
, len
-1, "%08x%08x",
8886 else if (hash_type
== HASH_TYPE_ORACLEH
)
8888 snprintf (out_buf
, len
-1, "%08X%08X",
8892 else if (hash_type
== HASH_TYPE_BCRYPT
)
8894 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8895 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8897 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8899 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8901 else if (hash_type
== HASH_TYPE_KECCAK
)
8903 uint
*ptr
= digest_buf
;
8905 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",
8933 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8935 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8937 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8944 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8946 digest_buf
[ 0] = digest_buf
[ 0];
8947 digest_buf
[ 1] = digest_buf
[ 1];
8948 digest_buf
[ 2] = digest_buf
[ 2];
8949 digest_buf
[ 3] = digest_buf
[ 3];
8950 digest_buf
[ 4] = digest_buf
[ 4];
8951 digest_buf
[ 5] = digest_buf
[ 5];
8952 digest_buf
[ 6] = digest_buf
[ 6];
8953 digest_buf
[ 7] = digest_buf
[ 7];
8954 digest_buf
[ 8] = digest_buf
[ 8];
8955 digest_buf
[ 9] = digest_buf
[ 9];
8956 digest_buf
[10] = digest_buf
[10];
8957 digest_buf
[11] = digest_buf
[11];
8958 digest_buf
[12] = digest_buf
[12];
8959 digest_buf
[13] = digest_buf
[13];
8960 digest_buf
[14] = digest_buf
[14];
8961 digest_buf
[15] = digest_buf
[15];
8963 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8981 else if (hash_type
== HASH_TYPE_GOST
)
8983 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8993 else if (hash_type
== HASH_TYPE_MYSQL
)
8995 snprintf (out_buf
, len
-1, "%08x%08x",
8999 else if (hash_type
== HASH_TYPE_LOTUS5
)
9001 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9007 else if (hash_type
== HASH_TYPE_LOTUS6
)
9009 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9010 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9011 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9012 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9014 char buf
[16] = { 0 };
9016 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9017 memcpy (buf
+ 5, digest_buf
, 9);
9021 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9023 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9026 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9028 else if (hash_type
== HASH_TYPE_LOTUS8
)
9030 char buf
[52] = { 0 };
9034 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9040 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9044 buf
[26] = salt
.salt_buf_pc
[0];
9045 buf
[27] = salt
.salt_buf_pc
[1];
9049 memcpy (buf
+ 28, digest_buf
, 8);
9051 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9055 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9057 else if (hash_type
== HASH_TYPE_CRC32
)
9059 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9063 if (salt_type
== SALT_TYPE_INTERN
)
9065 size_t pos
= strlen (out_buf
);
9067 out_buf
[pos
] = data
.separator
;
9069 char *ptr
= (char *) salt
.salt_buf
;
9071 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9073 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9077 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9079 memset (hccap
, 0, sizeof (hccap_t
));
9081 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9083 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9085 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9086 wpa_t
*wpa
= &wpas
[salt_pos
];
9088 hccap
->keyver
= wpa
->keyver
;
9090 hccap
->eapol_size
= wpa
->eapol_size
;
9092 if (wpa
->keyver
!= 1)
9094 uint eapol_tmp
[64] = { 0 };
9096 for (uint i
= 0; i
< 64; i
++)
9098 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9101 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9105 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9108 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9109 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9110 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9111 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9113 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9115 uint dgst_size
= data
.dgst_size
;
9117 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9119 if (wpa
->keyver
!= 1)
9121 uint digest_tmp
[4] = { 0 };
9123 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9124 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9125 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9126 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9128 memcpy (hccap
->keymic
, digest_tmp
, 16);
9132 memcpy (hccap
->keymic
, digest_ptr
, 16);
9136 void SuspendThreads ()
9138 if (data
.devices_status
== STATUS_RUNNING
)
9140 hc_timer_set (&data
.timer_paused
);
9142 data
.devices_status
= STATUS_PAUSED
;
9144 log_info ("Paused");
9148 void ResumeThreads ()
9150 if (data
.devices_status
== STATUS_PAUSED
)
9154 hc_timer_get (data
.timer_paused
, ms_paused
);
9156 data
.ms_paused
+= ms_paused
;
9158 data
.devices_status
= STATUS_RUNNING
;
9160 log_info ("Resumed");
9166 if (data
.devices_status
!= STATUS_RUNNING
) return;
9168 data
.devices_status
= STATUS_BYPASS
;
9170 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9173 void stop_at_checkpoint ()
9175 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9177 if (data
.devices_status
!= STATUS_RUNNING
) return;
9180 // this feature only makes sense if --restore-disable was not specified
9182 if (data
.restore_disable
== 1)
9184 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9189 // check if monitoring of Restore Point updates should be enabled or disabled
9191 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9193 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9195 // save the current restore point value
9197 data
.checkpoint_cur_words
= get_lowest_words_done ();
9199 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9203 data
.devices_status
= STATUS_RUNNING
;
9205 // reset the global value for checkpoint checks
9207 data
.checkpoint_cur_words
= 0;
9209 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9215 //if (data.devices_status == STATUS_INIT) return;
9216 //if (data.devices_status == STATUS_STARTING) return;
9218 data
.devices_status
= STATUS_ABORTED
;
9223 //if (data.devices_status == STATUS_INIT) return;
9224 //if (data.devices_status == STATUS_STARTING) return;
9226 data
.devices_status
= STATUS_QUIT
;
9229 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9231 const size_t len
= strlen (s
);
9233 for (size_t in
= 0; in
< len
; in
++)
9239 s
[in
] = replace_char
;
9244 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9246 char s_escaped
[1024] = { 0 };
9248 size_t s_escaped_max
= sizeof (s_escaped
);
9250 const size_t len
= strlen (s
);
9252 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9258 s_escaped
[out
] = escape_char
;
9263 if (out
== s_escaped_max
- 2) break;
9268 strncpy (s
, s_escaped
, s_max
- 1);
9271 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9273 FILE *fp
= fopen (kernel_file
, "rb");
9279 memset (&st
, 0, sizeof (st
));
9281 stat (kernel_file
, &st
);
9283 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9285 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9287 if (num_read
!= (size_t) st
.st_size
)
9289 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9296 buf
[st
.st_size
] = 0;
9298 for (int i
= 0; i
< num_devices
; i
++)
9300 kernel_lengths
[i
] = (size_t) st
.st_size
;
9302 kernel_sources
[i
] = buf
;
9307 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9315 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9317 if (binary_size
> 0)
9319 FILE *fp
= fopen (dst
, "wb");
9322 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9333 restore_data_t
*init_restore (int argc
, char **argv
)
9335 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9337 if (data
.restore_disable
== 0)
9339 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9343 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9347 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9356 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9358 int pidbin_len
= -1;
9361 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9363 FILE *fd
= fopen (pidbin
, "rb");
9367 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9369 pidbin
[pidbin_len
] = 0;
9373 char *argv0_r
= strrchr (argv
[0], '/');
9375 char *pidbin_r
= strrchr (pidbin
, '/');
9377 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9379 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9381 if (strcmp (argv0_r
, pidbin_r
) == 0)
9383 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9390 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9392 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9394 int pidbin2_len
= -1;
9396 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9397 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9399 pidbin
[pidbin_len
] = 0;
9400 pidbin2
[pidbin2_len
] = 0;
9404 if (strcmp (pidbin
, pidbin2
) == 0)
9406 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9419 if (rd
->version_bin
< RESTORE_MIN
)
9421 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9428 memset (rd
, 0, sizeof (restore_data_t
));
9430 rd
->version_bin
= VERSION_BIN
;
9433 rd
->pid
= getpid ();
9435 rd
->pid
= GetCurrentProcessId ();
9438 if (getcwd (rd
->cwd
, 255) == NULL
)
9451 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9453 FILE *fp
= fopen (eff_restore_file
, "rb");
9457 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9462 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9464 log_error ("ERROR: Can't read %s", eff_restore_file
);
9469 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9471 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9473 for (uint i
= 0; i
< rd
->argc
; i
++)
9475 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9477 log_error ("ERROR: Can't read %s", eff_restore_file
);
9482 size_t len
= strlen (buf
);
9484 if (len
) buf
[len
- 1] = 0;
9486 rd
->argv
[i
] = mystrdup (buf
);
9493 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9495 if (chdir (rd
->cwd
))
9497 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9498 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9499 " https://github.com/philsmd/analyze_hc_restore\n"
9500 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9506 u64
get_lowest_words_done ()
9510 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9512 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9514 if (device_param
->skipped
) continue;
9516 const u64 words_done
= device_param
->words_done
;
9518 if (words_done
< words_cur
) words_cur
= words_done
;
9521 // It's possible that a device's workload isn't finished right after a restore-case.
9522 // In that case, this function would return 0 and overwrite the real restore point
9523 // There's also data.words_cur which is set to rd->words_cur but it changes while
9524 // the attack is running therefore we should stick to rd->words_cur.
9525 // Note that -s influences rd->words_cur we should keep a close look on that.
9527 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9532 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9534 u64 words_cur
= get_lowest_words_done ();
9536 rd
->words_cur
= words_cur
;
9538 FILE *fp
= fopen (new_restore_file
, "wb");
9542 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9547 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9549 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9554 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9556 for (uint i
= 0; i
< rd
->argc
; i
++)
9558 fprintf (fp
, "%s", rd
->argv
[i
]);
9564 fsync (fileno (fp
));
9569 void cycle_restore ()
9571 const char *eff_restore_file
= data
.eff_restore_file
;
9572 const char *new_restore_file
= data
.new_restore_file
;
9574 restore_data_t
*rd
= data
.rd
;
9576 write_restore (new_restore_file
, rd
);
9580 memset (&st
, 0, sizeof(st
));
9582 if (stat (eff_restore_file
, &st
) == 0)
9584 if (unlink (eff_restore_file
))
9586 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9590 if (rename (new_restore_file
, eff_restore_file
))
9592 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9596 void check_checkpoint ()
9598 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9600 u64 words_cur
= get_lowest_words_done ();
9602 if (words_cur
!= data
.checkpoint_cur_words
)
9612 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9616 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9618 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9620 myfree (alias
->device_name
);
9621 myfree (alias
->alias_name
);
9624 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9626 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9628 myfree (entry
->device_name
);
9631 myfree (tuning_db
->alias_buf
);
9632 myfree (tuning_db
->entry_buf
);
9637 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9639 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9641 int num_lines
= count_lines (fp
);
9643 // a bit over-allocated
9645 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9646 tuning_db
->alias_cnt
= 0;
9648 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9649 tuning_db
->entry_cnt
= 0;
9654 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9656 FILE *fp
= fopen (tuning_db_file
, "rb");
9660 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9665 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9671 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9675 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9677 if (line_buf
== NULL
) break;
9681 const int line_len
= in_superchop (line_buf
);
9683 if (line_len
== 0) continue;
9685 if (line_buf
[0] == '#') continue;
9689 char *token_ptr
[7] = { NULL
};
9693 char *next
= strtok (line_buf
, "\t ");
9695 token_ptr
[token_cnt
] = next
;
9699 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9701 token_ptr
[token_cnt
] = next
;
9708 char *device_name
= token_ptr
[0];
9709 char *alias_name
= token_ptr
[1];
9711 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9713 alias
->device_name
= mystrdup (device_name
);
9714 alias
->alias_name
= mystrdup (alias_name
);
9716 tuning_db
->alias_cnt
++;
9718 else if (token_cnt
== 6)
9720 if ((token_ptr
[1][0] != '0') &&
9721 (token_ptr
[1][0] != '1') &&
9722 (token_ptr
[1][0] != '3') &&
9723 (token_ptr
[1][0] != '*'))
9725 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9730 if ((token_ptr
[3][0] != '1') &&
9731 (token_ptr
[3][0] != '2') &&
9732 (token_ptr
[3][0] != '4') &&
9733 (token_ptr
[3][0] != '8') &&
9734 (token_ptr
[3][0] != 'N'))
9736 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9741 char *device_name
= token_ptr
[0];
9743 int attack_mode
= -1;
9745 int vector_width
= -1;
9746 int kernel_accel
= -1;
9747 int kernel_loops
= -1;
9749 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9750 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9751 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9753 if (token_ptr
[4][0] != 'A')
9755 kernel_accel
= atoi (token_ptr
[4]);
9757 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9759 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9769 if (token_ptr
[5][0] != 'A')
9771 kernel_loops
= atoi (token_ptr
[5]);
9773 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9775 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9785 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9787 entry
->device_name
= mystrdup (device_name
);
9788 entry
->attack_mode
= attack_mode
;
9789 entry
->hash_type
= hash_type
;
9790 entry
->vector_width
= vector_width
;
9791 entry
->kernel_accel
= kernel_accel
;
9792 entry
->kernel_loops
= kernel_loops
;
9794 tuning_db
->entry_cnt
++;
9798 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9808 // todo: print loaded 'cnt' message
9810 // sort the database
9812 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9813 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9818 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9820 static tuning_db_entry_t s
;
9822 // first we need to convert all spaces in the device_name to underscore
9824 char *device_name_nospace
= strdup (device_param
->device_name
);
9826 int device_name_length
= strlen (device_name_nospace
);
9830 for (i
= 0; i
< device_name_length
; i
++)
9832 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9835 // find out if there's an alias configured
9837 tuning_db_alias_t a
;
9839 a
.device_name
= device_name_nospace
;
9841 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
);
9843 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9845 // attack-mode 6 and 7 are attack-mode 1 basically
9847 if (attack_mode
== 6) attack_mode
= 1;
9848 if (attack_mode
== 7) attack_mode
= 1;
9850 // bsearch is not ideal but fast enough
9852 s
.device_name
= device_name_nospace
;
9853 s
.attack_mode
= attack_mode
;
9854 s
.hash_type
= hash_type
;
9856 tuning_db_entry_t
*entry
= NULL
;
9858 // this will produce all 2^3 combinations required
9860 for (i
= 0; i
< 8; i
++)
9862 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9863 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9864 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9866 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9868 if (entry
!= NULL
) break;
9870 // in non-wildcard mode do some additional checks:
9874 // in case we have an alias-name
9876 if (alias_name
!= NULL
)
9878 s
.device_name
= alias_name
;
9880 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9882 if (entry
!= NULL
) break;
9885 // or by device type
9887 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9889 s
.device_name
= "DEVICE_TYPE_CPU";
9891 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9893 s
.device_name
= "DEVICE_TYPE_GPU";
9895 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9897 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9900 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9902 if (entry
!= NULL
) break;
9906 // free converted device_name
9908 myfree (device_name_nospace
);
9917 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9919 u8 tmp
[256] = { 0 };
9921 if (salt_len
> sizeof (tmp
))
9926 memcpy (tmp
, in
, salt_len
);
9928 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9930 if ((salt_len
% 2) == 0)
9932 u32 new_salt_len
= salt_len
/ 2;
9934 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9939 tmp
[i
] = hex_convert (p1
) << 0;
9940 tmp
[i
] |= hex_convert (p0
) << 4;
9943 salt_len
= new_salt_len
;
9950 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9952 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9955 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9957 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9961 u32
*tmp_uint
= (u32
*) tmp
;
9963 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9964 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9965 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9966 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9967 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9968 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9969 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9970 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9971 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9972 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9974 salt_len
= salt_len
* 2;
9982 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9984 lowercase (tmp
, salt_len
);
9987 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9989 uppercase (tmp
, salt_len
);
9994 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9999 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10004 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10006 u32
*tmp_uint
= (uint
*) tmp
;
10010 if (len
% 4) max
++;
10012 for (u32 i
= 0; i
< max
; i
++)
10014 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10017 // Important: we may need to increase the length of memcpy since
10018 // we don't want to "loose" some swapped bytes (could happen if
10019 // they do not perfectly fit in the 4-byte blocks)
10020 // Memcpy does always copy the bytes in the BE order, but since
10021 // we swapped them, some important bytes could be in positions
10022 // we normally skip with the original len
10024 if (len
% 4) len
+= 4 - (len
% 4);
10027 memcpy (out
, tmp
, len
);
10032 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10034 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10036 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10038 u32
*digest
= (u32
*) hash_buf
->digest
;
10040 salt_t
*salt
= hash_buf
->salt
;
10042 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10044 char *iter_pos
= input_buf
+ 4;
10046 salt
->salt_iter
= 1 << atoi (iter_pos
);
10048 char *salt_pos
= strchr (iter_pos
, '$');
10050 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10054 uint salt_len
= 16;
10056 salt
->salt_len
= salt_len
;
10058 u8 tmp_buf
[100] = { 0 };
10060 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10064 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10066 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10067 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10068 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10069 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10071 char *hash_pos
= salt_pos
+ 22;
10073 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10075 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10077 memcpy (digest
, tmp_buf
, 24);
10079 digest
[0] = byte_swap_32 (digest
[0]);
10080 digest
[1] = byte_swap_32 (digest
[1]);
10081 digest
[2] = byte_swap_32 (digest
[2]);
10082 digest
[3] = byte_swap_32 (digest
[3]);
10083 digest
[4] = byte_swap_32 (digest
[4]);
10084 digest
[5] = byte_swap_32 (digest
[5]);
10086 digest
[5] &= ~0xff; // its just 23 not 24 !
10088 return (PARSER_OK
);
10091 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10093 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10095 u32
*digest
= (u32
*) hash_buf
->digest
;
10097 u8 tmp_buf
[100] = { 0 };
10099 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10101 memcpy (digest
, tmp_buf
, 32);
10103 digest
[0] = byte_swap_32 (digest
[0]);
10104 digest
[1] = byte_swap_32 (digest
[1]);
10105 digest
[2] = byte_swap_32 (digest
[2]);
10106 digest
[3] = byte_swap_32 (digest
[3]);
10107 digest
[4] = byte_swap_32 (digest
[4]);
10108 digest
[5] = byte_swap_32 (digest
[5]);
10109 digest
[6] = byte_swap_32 (digest
[6]);
10110 digest
[7] = byte_swap_32 (digest
[7]);
10112 digest
[0] -= SHA256M_A
;
10113 digest
[1] -= SHA256M_B
;
10114 digest
[2] -= SHA256M_C
;
10115 digest
[3] -= SHA256M_D
;
10116 digest
[4] -= SHA256M_E
;
10117 digest
[5] -= SHA256M_F
;
10118 digest
[6] -= SHA256M_G
;
10119 digest
[7] -= SHA256M_H
;
10121 return (PARSER_OK
);
10124 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10126 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10128 u32
*digest
= (u32
*) hash_buf
->digest
;
10130 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10131 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10133 digest
[0] = byte_swap_32 (digest
[0]);
10134 digest
[1] = byte_swap_32 (digest
[1]);
10138 IP (digest
[0], digest
[1], tt
);
10140 digest
[0] = digest
[0];
10141 digest
[1] = digest
[1];
10145 return (PARSER_OK
);
10148 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10150 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10152 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10154 u32
*digest
= (u32
*) hash_buf
->digest
;
10156 salt_t
*salt
= hash_buf
->salt
;
10158 char *hash_pos
= input_buf
+ 10;
10160 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10161 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10162 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10163 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10164 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10166 digest
[0] -= SHA1M_A
;
10167 digest
[1] -= SHA1M_B
;
10168 digest
[2] -= SHA1M_C
;
10169 digest
[3] -= SHA1M_D
;
10170 digest
[4] -= SHA1M_E
;
10172 uint salt_len
= 10;
10174 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10176 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10178 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10180 salt
->salt_len
= salt_len
;
10182 return (PARSER_OK
);
10185 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10187 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10189 u32
*digest
= (u32
*) hash_buf
->digest
;
10191 salt_t
*salt
= hash_buf
->salt
;
10193 char *hash_pos
= input_buf
+ 8;
10195 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10196 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10197 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10198 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10199 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10201 digest
[0] -= SHA1M_A
;
10202 digest
[1] -= SHA1M_B
;
10203 digest
[2] -= SHA1M_C
;
10204 digest
[3] -= SHA1M_D
;
10205 digest
[4] -= SHA1M_E
;
10209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10211 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10215 salt
->salt_len
= salt_len
;
10217 return (PARSER_OK
);
10220 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10222 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10224 u64
*digest
= (u64
*) hash_buf
->digest
;
10226 salt_t
*salt
= hash_buf
->salt
;
10228 char *hash_pos
= input_buf
+ 8;
10230 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10231 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10232 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10233 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10234 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10235 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10236 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10237 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10239 digest
[0] -= SHA512M_A
;
10240 digest
[1] -= SHA512M_B
;
10241 digest
[2] -= SHA512M_C
;
10242 digest
[3] -= SHA512M_D
;
10243 digest
[4] -= SHA512M_E
;
10244 digest
[5] -= SHA512M_F
;
10245 digest
[6] -= SHA512M_G
;
10246 digest
[7] -= SHA512M_H
;
10250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10252 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10256 salt
->salt_len
= salt_len
;
10258 return (PARSER_OK
);
10261 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10263 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10265 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10269 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10272 u32
*digest
= (u32
*) hash_buf
->digest
;
10274 salt_t
*salt
= hash_buf
->salt
;
10276 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10277 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10278 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10279 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10281 digest
[0] = byte_swap_32 (digest
[0]);
10282 digest
[1] = byte_swap_32 (digest
[1]);
10283 digest
[2] = byte_swap_32 (digest
[2]);
10284 digest
[3] = byte_swap_32 (digest
[3]);
10286 digest
[0] -= MD5M_A
;
10287 digest
[1] -= MD5M_B
;
10288 digest
[2] -= MD5M_C
;
10289 digest
[3] -= MD5M_D
;
10291 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10293 uint salt_len
= input_len
- 32 - 1;
10295 char *salt_buf
= input_buf
+ 32 + 1;
10297 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10303 salt
->salt_len
= salt_len
;
10305 return (PARSER_OK
);
10308 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10310 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10312 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10316 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10321 char clean_input_buf
[32] = { 0 };
10323 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10324 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10326 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10330 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10336 clean_input_buf
[k
] = input_buf
[i
];
10344 u32
*digest
= (u32
*) hash_buf
->digest
;
10346 salt_t
*salt
= hash_buf
->salt
;
10348 u32 a
, b
, c
, d
, e
, f
;
10350 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10351 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10352 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10353 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10354 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10355 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10357 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10358 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10360 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10361 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10362 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10363 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10364 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10365 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10367 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10368 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10370 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10371 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10372 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10373 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10374 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10375 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10377 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10378 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10380 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10381 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10382 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10383 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10384 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10385 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10387 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10388 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10390 digest
[0] = byte_swap_32 (digest
[0]);
10391 digest
[1] = byte_swap_32 (digest
[1]);
10392 digest
[2] = byte_swap_32 (digest
[2]);
10393 digest
[3] = byte_swap_32 (digest
[3]);
10395 digest
[0] -= MD5M_A
;
10396 digest
[1] -= MD5M_B
;
10397 digest
[2] -= MD5M_C
;
10398 digest
[3] -= MD5M_D
;
10400 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10402 uint salt_len
= input_len
- 30 - 1;
10404 char *salt_buf
= input_buf
+ 30 + 1;
10406 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10408 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10410 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10411 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10413 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10415 salt
->salt_len
= salt_len
;
10417 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10419 salt
->salt_len
+= 22;
10421 return (PARSER_OK
);
10424 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10426 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10428 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10432 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10435 u32
*digest
= (u32
*) hash_buf
->digest
;
10437 salt_t
*salt
= hash_buf
->salt
;
10439 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10440 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10441 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10442 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10443 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10445 digest
[0] -= SHA1M_A
;
10446 digest
[1] -= SHA1M_B
;
10447 digest
[2] -= SHA1M_C
;
10448 digest
[3] -= SHA1M_D
;
10449 digest
[4] -= SHA1M_E
;
10451 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10453 uint salt_len
= input_len
- 40 - 1;
10455 char *salt_buf
= input_buf
+ 40 + 1;
10457 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10459 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10461 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10463 salt
->salt_len
= salt_len
;
10465 return (PARSER_OK
);
10468 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10470 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10472 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10476 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10479 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10481 char *iter_pos
= input_buf
+ 6;
10483 salt_t
*salt
= hash_buf
->salt
;
10485 uint iter
= atoi (iter_pos
);
10489 iter
= ROUNDS_DCC2
;
10492 salt
->salt_iter
= iter
- 1;
10494 char *salt_pos
= strchr (iter_pos
, '#');
10496 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10500 char *digest_pos
= strchr (salt_pos
, '#');
10502 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10506 uint salt_len
= digest_pos
- salt_pos
- 1;
10508 u32
*digest
= (u32
*) hash_buf
->digest
;
10510 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10511 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10512 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10513 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10517 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10519 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10521 salt
->salt_len
= salt_len
;
10523 return (PARSER_OK
);
10526 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10528 u32
*digest
= (u32
*) hash_buf
->digest
;
10530 salt_t
*salt
= hash_buf
->salt
;
10532 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10536 memcpy (&in
, input_buf
, input_len
);
10538 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10540 memcpy (digest
, in
.keymic
, 16);
10543 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10544 The phrase "Pairwise key expansion"
10545 Access Point Address (referred to as Authenticator Address AA)
10546 Supplicant Address (referred to as Supplicant Address SA)
10547 Access Point Nonce (referred to as Authenticator Anonce)
10548 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10551 uint salt_len
= strlen (in
.essid
);
10555 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10557 return (PARSER_SALT_LENGTH
);
10560 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10562 salt
->salt_len
= salt_len
;
10564 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10566 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10568 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10570 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10572 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10573 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10577 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10578 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10581 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10583 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10584 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10588 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10589 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10592 for (int i
= 0; i
< 25; i
++)
10594 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10597 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10598 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10599 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10600 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10602 wpa
->keyver
= in
.keyver
;
10604 if (wpa
->keyver
> 255)
10606 log_info ("ATTENTION!");
10607 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10608 log_info (" This could be due to a recent aircrack-ng bug.");
10609 log_info (" The key version was automatically reset to a reasonable value.");
10612 wpa
->keyver
&= 0xff;
10615 wpa
->eapol_size
= in
.eapol_size
;
10617 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10619 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10621 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10623 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10625 if (wpa
->keyver
== 1)
10631 digest
[0] = byte_swap_32 (digest
[0]);
10632 digest
[1] = byte_swap_32 (digest
[1]);
10633 digest
[2] = byte_swap_32 (digest
[2]);
10634 digest
[3] = byte_swap_32 (digest
[3]);
10636 for (int i
= 0; i
< 64; i
++)
10638 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10642 uint32_t *p0
= (uint32_t *) in
.essid
;
10646 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10647 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10649 salt
->salt_buf
[10] = c0
;
10650 salt
->salt_buf
[11] = c1
;
10652 return (PARSER_OK
);
10655 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10657 u32
*digest
= (u32
*) hash_buf
->digest
;
10659 salt_t
*salt
= hash_buf
->salt
;
10661 if (input_len
== 0)
10663 log_error ("Password Safe v2 container not specified");
10668 FILE *fp
= fopen (input_buf
, "rb");
10672 log_error ("%s: %s", input_buf
, strerror (errno
));
10679 memset (&buf
, 0, sizeof (psafe2_hdr
));
10681 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10685 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10687 salt
->salt_buf
[0] = buf
.random
[0];
10688 salt
->salt_buf
[1] = buf
.random
[1];
10690 salt
->salt_len
= 8;
10691 salt
->salt_iter
= 1000;
10693 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10694 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10695 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10696 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10697 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10699 return (PARSER_OK
);
10702 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10704 u32
*digest
= (u32
*) hash_buf
->digest
;
10706 salt_t
*salt
= hash_buf
->salt
;
10708 if (input_len
== 0)
10710 log_error (".psafe3 not specified");
10715 FILE *fp
= fopen (input_buf
, "rb");
10719 log_error ("%s: %s", input_buf
, strerror (errno
));
10726 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10730 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10732 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10734 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10736 salt
->salt_iter
= in
.iterations
+ 1;
10738 salt
->salt_buf
[0] = in
.salt_buf
[0];
10739 salt
->salt_buf
[1] = in
.salt_buf
[1];
10740 salt
->salt_buf
[2] = in
.salt_buf
[2];
10741 salt
->salt_buf
[3] = in
.salt_buf
[3];
10742 salt
->salt_buf
[4] = in
.salt_buf
[4];
10743 salt
->salt_buf
[5] = in
.salt_buf
[5];
10744 salt
->salt_buf
[6] = in
.salt_buf
[6];
10745 salt
->salt_buf
[7] = in
.salt_buf
[7];
10747 salt
->salt_len
= 32;
10749 digest
[0] = in
.hash_buf
[0];
10750 digest
[1] = in
.hash_buf
[1];
10751 digest
[2] = in
.hash_buf
[2];
10752 digest
[3] = in
.hash_buf
[3];
10753 digest
[4] = in
.hash_buf
[4];
10754 digest
[5] = in
.hash_buf
[5];
10755 digest
[6] = in
.hash_buf
[6];
10756 digest
[7] = in
.hash_buf
[7];
10758 digest
[0] = byte_swap_32 (digest
[0]);
10759 digest
[1] = byte_swap_32 (digest
[1]);
10760 digest
[2] = byte_swap_32 (digest
[2]);
10761 digest
[3] = byte_swap_32 (digest
[3]);
10762 digest
[4] = byte_swap_32 (digest
[4]);
10763 digest
[5] = byte_swap_32 (digest
[5]);
10764 digest
[6] = byte_swap_32 (digest
[6]);
10765 digest
[7] = byte_swap_32 (digest
[7]);
10767 return (PARSER_OK
);
10770 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10772 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10774 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10776 u32
*digest
= (u32
*) hash_buf
->digest
;
10778 salt_t
*salt
= hash_buf
->salt
;
10780 char *iter_pos
= input_buf
+ 3;
10782 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10784 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10786 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10788 salt
->salt_iter
= salt_iter
;
10790 char *salt_pos
= iter_pos
+ 1;
10794 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10796 salt
->salt_len
= salt_len
;
10798 char *hash_pos
= salt_pos
+ salt_len
;
10800 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10802 return (PARSER_OK
);
10805 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10807 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10809 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10811 u32
*digest
= (u32
*) hash_buf
->digest
;
10813 salt_t
*salt
= hash_buf
->salt
;
10815 char *salt_pos
= input_buf
+ 3;
10817 uint iterations_len
= 0;
10819 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10823 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10825 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10826 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10830 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10834 iterations_len
+= 8;
10838 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10841 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10843 char *hash_pos
= strchr (salt_pos
, '$');
10845 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10847 uint salt_len
= hash_pos
- salt_pos
;
10849 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10851 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10853 salt
->salt_len
= salt_len
;
10857 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10859 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10861 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10863 return (PARSER_OK
);
10866 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10868 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10870 u32
*digest
= (u32
*) hash_buf
->digest
;
10872 salt_t
*salt
= hash_buf
->salt
;
10874 char *salt_pos
= input_buf
+ 6;
10876 uint iterations_len
= 0;
10878 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10882 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10884 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10885 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10889 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10893 iterations_len
+= 8;
10897 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10900 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10902 char *hash_pos
= strchr (salt_pos
, '$');
10904 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10906 uint salt_len
= hash_pos
- salt_pos
;
10908 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10910 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10912 salt
->salt_len
= salt_len
;
10916 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10918 return (PARSER_OK
);
10921 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10923 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10925 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10927 u32
*digest
= (u32
*) hash_buf
->digest
;
10929 salt_t
*salt
= hash_buf
->salt
;
10931 char *salt_pos
= input_buf
+ 14;
10933 char *hash_pos
= strchr (salt_pos
, '*');
10935 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10939 uint salt_len
= hash_pos
- salt_pos
- 1;
10941 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10943 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10945 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10947 salt
->salt_len
= salt_len
;
10949 u8 tmp_buf
[100] = { 0 };
10951 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10953 memcpy (digest
, tmp_buf
, 20);
10955 digest
[0] = byte_swap_32 (digest
[0]);
10956 digest
[1] = byte_swap_32 (digest
[1]);
10957 digest
[2] = byte_swap_32 (digest
[2]);
10958 digest
[3] = byte_swap_32 (digest
[3]);
10959 digest
[4] = byte_swap_32 (digest
[4]);
10961 digest
[0] -= SHA1M_A
;
10962 digest
[1] -= SHA1M_B
;
10963 digest
[2] -= SHA1M_C
;
10964 digest
[3] -= SHA1M_D
;
10965 digest
[4] -= SHA1M_E
;
10967 return (PARSER_OK
);
10970 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10972 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10974 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10976 if (c12
& 3) return (PARSER_HASH_VALUE
);
10978 u32
*digest
= (u32
*) hash_buf
->digest
;
10980 salt_t
*salt
= hash_buf
->salt
;
10982 // for ascii_digest
10983 salt
->salt_sign
[0] = input_buf
[0];
10984 salt
->salt_sign
[1] = input_buf
[1];
10986 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10987 | itoa64_to_int (input_buf
[1]) << 6;
10989 salt
->salt_len
= 2;
10991 u8 tmp_buf
[100] = { 0 };
10993 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10995 memcpy (digest
, tmp_buf
, 8);
10999 IP (digest
[0], digest
[1], tt
);
11004 return (PARSER_OK
);
11007 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11009 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11011 u32
*digest
= (u32
*) hash_buf
->digest
;
11013 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11014 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11015 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11016 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11018 digest
[0] = byte_swap_32 (digest
[0]);
11019 digest
[1] = byte_swap_32 (digest
[1]);
11020 digest
[2] = byte_swap_32 (digest
[2]);
11021 digest
[3] = byte_swap_32 (digest
[3]);
11023 digest
[0] -= MD4M_A
;
11024 digest
[1] -= MD4M_B
;
11025 digest
[2] -= MD4M_C
;
11026 digest
[3] -= MD4M_D
;
11028 return (PARSER_OK
);
11031 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11033 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11035 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11039 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11042 u32
*digest
= (u32
*) hash_buf
->digest
;
11044 salt_t
*salt
= hash_buf
->salt
;
11046 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11047 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11048 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11049 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11051 digest
[0] = byte_swap_32 (digest
[0]);
11052 digest
[1] = byte_swap_32 (digest
[1]);
11053 digest
[2] = byte_swap_32 (digest
[2]);
11054 digest
[3] = byte_swap_32 (digest
[3]);
11056 digest
[0] -= MD4M_A
;
11057 digest
[1] -= MD4M_B
;
11058 digest
[2] -= MD4M_C
;
11059 digest
[3] -= MD4M_D
;
11061 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11063 uint salt_len
= input_len
- 32 - 1;
11065 char *salt_buf
= input_buf
+ 32 + 1;
11067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11073 salt
->salt_len
= salt_len
;
11075 return (PARSER_OK
);
11078 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11080 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11082 u32
*digest
= (u32
*) hash_buf
->digest
;
11084 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11085 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11086 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11087 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11089 digest
[0] = byte_swap_32 (digest
[0]);
11090 digest
[1] = byte_swap_32 (digest
[1]);
11091 digest
[2] = byte_swap_32 (digest
[2]);
11092 digest
[3] = byte_swap_32 (digest
[3]);
11094 digest
[0] -= MD5M_A
;
11095 digest
[1] -= MD5M_B
;
11096 digest
[2] -= MD5M_C
;
11097 digest
[3] -= MD5M_D
;
11099 return (PARSER_OK
);
11102 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11104 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11106 u32
*digest
= (u32
*) hash_buf
->digest
;
11108 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11109 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11113 digest
[0] = byte_swap_32 (digest
[0]);
11114 digest
[1] = byte_swap_32 (digest
[1]);
11116 return (PARSER_OK
);
11119 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11123 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11127 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11130 u32
*digest
= (u32
*) hash_buf
->digest
;
11132 salt_t
*salt
= hash_buf
->salt
;
11134 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11135 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11136 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11137 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11139 digest
[0] = byte_swap_32 (digest
[0]);
11140 digest
[1] = byte_swap_32 (digest
[1]);
11141 digest
[2] = byte_swap_32 (digest
[2]);
11142 digest
[3] = byte_swap_32 (digest
[3]);
11144 digest
[0] -= MD5M_A
;
11145 digest
[1] -= MD5M_B
;
11146 digest
[2] -= MD5M_C
;
11147 digest
[3] -= MD5M_D
;
11149 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11151 uint salt_len
= input_len
- 32 - 1;
11153 char *salt_buf
= input_buf
+ 32 + 1;
11155 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11157 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11159 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11161 salt
->salt_len
= salt_len
;
11163 return (PARSER_OK
);
11166 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11168 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11170 u32
*digest
= (u32
*) hash_buf
->digest
;
11172 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11173 | itoa64_to_int (input_buf
[ 1]) << 6
11174 | itoa64_to_int (input_buf
[ 2]) << 12
11175 | itoa64_to_int (input_buf
[ 3]) << 18;
11176 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11177 | itoa64_to_int (input_buf
[ 5]) << 6
11178 | itoa64_to_int (input_buf
[ 6]) << 12
11179 | itoa64_to_int (input_buf
[ 7]) << 18;
11180 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11181 | itoa64_to_int (input_buf
[ 9]) << 6
11182 | itoa64_to_int (input_buf
[10]) << 12
11183 | itoa64_to_int (input_buf
[11]) << 18;
11184 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11185 | itoa64_to_int (input_buf
[13]) << 6
11186 | itoa64_to_int (input_buf
[14]) << 12
11187 | itoa64_to_int (input_buf
[15]) << 18;
11189 digest
[0] -= MD5M_A
;
11190 digest
[1] -= MD5M_B
;
11191 digest
[2] -= MD5M_C
;
11192 digest
[3] -= MD5M_D
;
11194 digest
[0] &= 0x00ffffff;
11195 digest
[1] &= 0x00ffffff;
11196 digest
[2] &= 0x00ffffff;
11197 digest
[3] &= 0x00ffffff;
11199 return (PARSER_OK
);
11202 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11204 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11206 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11210 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11213 u32
*digest
= (u32
*) hash_buf
->digest
;
11215 salt_t
*salt
= hash_buf
->salt
;
11217 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11218 | itoa64_to_int (input_buf
[ 1]) << 6
11219 | itoa64_to_int (input_buf
[ 2]) << 12
11220 | itoa64_to_int (input_buf
[ 3]) << 18;
11221 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11222 | itoa64_to_int (input_buf
[ 5]) << 6
11223 | itoa64_to_int (input_buf
[ 6]) << 12
11224 | itoa64_to_int (input_buf
[ 7]) << 18;
11225 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11226 | itoa64_to_int (input_buf
[ 9]) << 6
11227 | itoa64_to_int (input_buf
[10]) << 12
11228 | itoa64_to_int (input_buf
[11]) << 18;
11229 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11230 | itoa64_to_int (input_buf
[13]) << 6
11231 | itoa64_to_int (input_buf
[14]) << 12
11232 | itoa64_to_int (input_buf
[15]) << 18;
11234 digest
[0] -= MD5M_A
;
11235 digest
[1] -= MD5M_B
;
11236 digest
[2] -= MD5M_C
;
11237 digest
[3] -= MD5M_D
;
11239 digest
[0] &= 0x00ffffff;
11240 digest
[1] &= 0x00ffffff;
11241 digest
[2] &= 0x00ffffff;
11242 digest
[3] &= 0x00ffffff;
11244 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11246 uint salt_len
= input_len
- 16 - 1;
11248 char *salt_buf
= input_buf
+ 16 + 1;
11250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11256 salt
->salt_len
= salt_len
;
11258 return (PARSER_OK
);
11261 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11263 key
[0] = (nthash
[0] >> 0);
11264 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11265 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11266 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11267 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11268 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11269 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11270 key
[7] = (nthash
[6] << 1);
11282 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11284 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11286 u32
*digest
= (u32
*) hash_buf
->digest
;
11288 salt_t
*salt
= hash_buf
->salt
;
11290 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11296 char *user_pos
= input_buf
;
11298 char *unused_pos
= strchr (user_pos
, ':');
11300 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11302 uint user_len
= unused_pos
- user_pos
;
11304 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11308 char *domain_pos
= strchr (unused_pos
, ':');
11310 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11312 uint unused_len
= domain_pos
- unused_pos
;
11314 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11318 char *srvchall_pos
= strchr (domain_pos
, ':');
11320 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11322 uint domain_len
= srvchall_pos
- domain_pos
;
11324 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11328 char *hash_pos
= strchr (srvchall_pos
, ':');
11330 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11332 uint srvchall_len
= hash_pos
- srvchall_pos
;
11334 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11338 char *clichall_pos
= strchr (hash_pos
, ':');
11340 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11342 uint hash_len
= clichall_pos
- hash_pos
;
11344 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11348 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11350 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11353 * store some data for later use
11356 netntlm
->user_len
= user_len
* 2;
11357 netntlm
->domain_len
= domain_len
* 2;
11358 netntlm
->srvchall_len
= srvchall_len
/ 2;
11359 netntlm
->clichall_len
= clichall_len
/ 2;
11361 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11362 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11365 * handle username and domainname
11368 for (uint i
= 0; i
< user_len
; i
++)
11370 *userdomain_ptr
++ = user_pos
[i
];
11371 *userdomain_ptr
++ = 0;
11374 for (uint i
= 0; i
< domain_len
; i
++)
11376 *userdomain_ptr
++ = domain_pos
[i
];
11377 *userdomain_ptr
++ = 0;
11381 * handle server challenge encoding
11384 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11386 const char p0
= srvchall_pos
[i
+ 0];
11387 const char p1
= srvchall_pos
[i
+ 1];
11389 *chall_ptr
++ = hex_convert (p1
) << 0
11390 | hex_convert (p0
) << 4;
11394 * handle client challenge encoding
11397 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11399 const char p0
= clichall_pos
[i
+ 0];
11400 const char p1
= clichall_pos
[i
+ 1];
11402 *chall_ptr
++ = hex_convert (p1
) << 0
11403 | hex_convert (p0
) << 4;
11410 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11412 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11414 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11416 salt
->salt_len
= salt_len
;
11418 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11419 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11420 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11421 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11423 digest
[0] = byte_swap_32 (digest
[0]);
11424 digest
[1] = byte_swap_32 (digest
[1]);
11425 digest
[2] = byte_swap_32 (digest
[2]);
11426 digest
[3] = byte_swap_32 (digest
[3]);
11428 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11430 uint digest_tmp
[2] = { 0 };
11432 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11433 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11435 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11436 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11438 /* special case 2: ESS */
11440 if (srvchall_len
== 48)
11442 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11444 uint w
[16] = { 0 };
11446 w
[ 0] = netntlm
->chall_buf
[6];
11447 w
[ 1] = netntlm
->chall_buf
[7];
11448 w
[ 2] = netntlm
->chall_buf
[0];
11449 w
[ 3] = netntlm
->chall_buf
[1];
11453 uint dgst
[4] = { 0 };
11462 salt
->salt_buf
[0] = dgst
[0];
11463 salt
->salt_buf
[1] = dgst
[1];
11467 /* precompute netntlmv1 exploit start */
11469 for (uint i
= 0; i
< 0x10000; i
++)
11471 uint key_md4
[2] = { i
, 0 };
11472 uint key_des
[2] = { 0, 0 };
11474 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11476 uint Kc
[16] = { 0 };
11477 uint Kd
[16] = { 0 };
11479 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11481 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11483 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11485 if (data3
[0] != digest_tmp
[0]) continue;
11486 if (data3
[1] != digest_tmp
[1]) continue;
11488 salt
->salt_buf
[2] = i
;
11490 salt
->salt_len
= 24;
11495 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11496 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11498 /* precompute netntlmv1 exploit stop */
11502 IP (digest
[0], digest
[1], tt
);
11503 IP (digest
[2], digest
[3], tt
);
11505 digest
[0] = rotr32 (digest
[0], 29);
11506 digest
[1] = rotr32 (digest
[1], 29);
11507 digest
[2] = rotr32 (digest
[2], 29);
11508 digest
[3] = rotr32 (digest
[3], 29);
11510 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11512 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11513 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11515 return (PARSER_OK
);
11518 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11520 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11522 u32
*digest
= (u32
*) hash_buf
->digest
;
11524 salt_t
*salt
= hash_buf
->salt
;
11526 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11532 char *user_pos
= input_buf
;
11534 char *unused_pos
= strchr (user_pos
, ':');
11536 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11538 uint user_len
= unused_pos
- user_pos
;
11540 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11544 char *domain_pos
= strchr (unused_pos
, ':');
11546 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11548 uint unused_len
= domain_pos
- unused_pos
;
11550 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11554 char *srvchall_pos
= strchr (domain_pos
, ':');
11556 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11558 uint domain_len
= srvchall_pos
- domain_pos
;
11560 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11564 char *hash_pos
= strchr (srvchall_pos
, ':');
11566 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11568 uint srvchall_len
= hash_pos
- srvchall_pos
;
11570 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11574 char *clichall_pos
= strchr (hash_pos
, ':');
11576 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11578 uint hash_len
= clichall_pos
- hash_pos
;
11580 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11584 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11586 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11588 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11591 * store some data for later use
11594 netntlm
->user_len
= user_len
* 2;
11595 netntlm
->domain_len
= domain_len
* 2;
11596 netntlm
->srvchall_len
= srvchall_len
/ 2;
11597 netntlm
->clichall_len
= clichall_len
/ 2;
11599 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11600 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11603 * handle username and domainname
11606 for (uint i
= 0; i
< user_len
; i
++)
11608 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11609 *userdomain_ptr
++ = 0;
11612 for (uint i
= 0; i
< domain_len
; i
++)
11614 *userdomain_ptr
++ = domain_pos
[i
];
11615 *userdomain_ptr
++ = 0;
11618 *userdomain_ptr
++ = 0x80;
11621 * handle server challenge encoding
11624 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11626 const char p0
= srvchall_pos
[i
+ 0];
11627 const char p1
= srvchall_pos
[i
+ 1];
11629 *chall_ptr
++ = hex_convert (p1
) << 0
11630 | hex_convert (p0
) << 4;
11634 * handle client challenge encoding
11637 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11639 const char p0
= clichall_pos
[i
+ 0];
11640 const char p1
= clichall_pos
[i
+ 1];
11642 *chall_ptr
++ = hex_convert (p1
) << 0
11643 | hex_convert (p0
) << 4;
11646 *chall_ptr
++ = 0x80;
11649 * handle hash itself
11652 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11653 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11654 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11655 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11657 digest
[0] = byte_swap_32 (digest
[0]);
11658 digest
[1] = byte_swap_32 (digest
[1]);
11659 digest
[2] = byte_swap_32 (digest
[2]);
11660 digest
[3] = byte_swap_32 (digest
[3]);
11663 * reuse challange data as salt_buf, its the buffer that is most likely unique
11666 salt
->salt_buf
[0] = 0;
11667 salt
->salt_buf
[1] = 0;
11668 salt
->salt_buf
[2] = 0;
11669 salt
->salt_buf
[3] = 0;
11670 salt
->salt_buf
[4] = 0;
11671 salt
->salt_buf
[5] = 0;
11672 salt
->salt_buf
[6] = 0;
11673 salt
->salt_buf
[7] = 0;
11677 uptr
= (uint
*) netntlm
->userdomain_buf
;
11679 for (uint i
= 0; i
< 16; i
+= 16)
11681 md5_64 (uptr
, salt
->salt_buf
);
11684 uptr
= (uint
*) netntlm
->chall_buf
;
11686 for (uint i
= 0; i
< 256; i
+= 16)
11688 md5_64 (uptr
, salt
->salt_buf
);
11691 salt
->salt_len
= 16;
11693 return (PARSER_OK
);
11696 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11698 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11700 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11704 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11707 u32
*digest
= (u32
*) hash_buf
->digest
;
11709 salt_t
*salt
= hash_buf
->salt
;
11711 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11712 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11713 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11714 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11716 digest
[0] = byte_swap_32 (digest
[0]);
11717 digest
[1] = byte_swap_32 (digest
[1]);
11718 digest
[2] = byte_swap_32 (digest
[2]);
11719 digest
[3] = byte_swap_32 (digest
[3]);
11721 digest
[0] -= MD5M_A
;
11722 digest
[1] -= MD5M_B
;
11723 digest
[2] -= MD5M_C
;
11724 digest
[3] -= MD5M_D
;
11726 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11728 uint salt_len
= input_len
- 32 - 1;
11730 char *salt_buf
= input_buf
+ 32 + 1;
11732 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11734 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11736 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11738 salt
->salt_len
= salt_len
;
11740 return (PARSER_OK
);
11743 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11745 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11747 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11751 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11754 u32
*digest
= (u32
*) hash_buf
->digest
;
11756 salt_t
*salt
= hash_buf
->salt
;
11758 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11759 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11760 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11761 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11763 digest
[0] = byte_swap_32 (digest
[0]);
11764 digest
[1] = byte_swap_32 (digest
[1]);
11765 digest
[2] = byte_swap_32 (digest
[2]);
11766 digest
[3] = byte_swap_32 (digest
[3]);
11768 digest
[0] -= MD5M_A
;
11769 digest
[1] -= MD5M_B
;
11770 digest
[2] -= MD5M_C
;
11771 digest
[3] -= MD5M_D
;
11773 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11775 uint salt_len
= input_len
- 32 - 1;
11777 char *salt_buf
= input_buf
+ 32 + 1;
11779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11781 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11783 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11785 salt
->salt_len
= salt_len
;
11787 return (PARSER_OK
);
11790 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11792 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11794 u32
*digest
= (u32
*) hash_buf
->digest
;
11796 salt_t
*salt
= hash_buf
->salt
;
11798 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11799 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11800 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11801 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11803 digest
[0] = byte_swap_32 (digest
[0]);
11804 digest
[1] = byte_swap_32 (digest
[1]);
11805 digest
[2] = byte_swap_32 (digest
[2]);
11806 digest
[3] = byte_swap_32 (digest
[3]);
11808 digest
[0] -= MD5M_A
;
11809 digest
[1] -= MD5M_B
;
11810 digest
[2] -= MD5M_C
;
11811 digest
[3] -= MD5M_D
;
11814 * This is a virtual salt. While the algorithm is basically not salted
11815 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11816 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11819 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11821 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11823 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11825 salt
->salt_len
= salt_len
;
11827 return (PARSER_OK
);
11830 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11832 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11834 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11838 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11841 u32
*digest
= (u32
*) hash_buf
->digest
;
11843 salt_t
*salt
= hash_buf
->salt
;
11845 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11846 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11847 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11848 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11850 digest
[0] = byte_swap_32 (digest
[0]);
11851 digest
[1] = byte_swap_32 (digest
[1]);
11852 digest
[2] = byte_swap_32 (digest
[2]);
11853 digest
[3] = byte_swap_32 (digest
[3]);
11855 digest
[0] -= MD5M_A
;
11856 digest
[1] -= MD5M_B
;
11857 digest
[2] -= MD5M_C
;
11858 digest
[3] -= MD5M_D
;
11860 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11862 uint salt_len
= input_len
- 32 - 1;
11864 char *salt_buf
= input_buf
+ 32 + 1;
11866 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11868 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11870 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11872 salt
->salt_len
= salt_len
;
11874 return (PARSER_OK
);
11877 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11879 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11881 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11885 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11888 u32
*digest
= (u32
*) hash_buf
->digest
;
11890 salt_t
*salt
= hash_buf
->salt
;
11892 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11893 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11894 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11895 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11897 digest
[0] = byte_swap_32 (digest
[0]);
11898 digest
[1] = byte_swap_32 (digest
[1]);
11899 digest
[2] = byte_swap_32 (digest
[2]);
11900 digest
[3] = byte_swap_32 (digest
[3]);
11902 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11904 uint salt_len
= input_len
- 32 - 1;
11906 char *salt_buf
= input_buf
+ 32 + 1;
11908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11914 salt
->salt_len
= salt_len
;
11916 return (PARSER_OK
);
11919 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11921 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11923 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11927 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11930 u32
*digest
= (u32
*) hash_buf
->digest
;
11932 salt_t
*salt
= hash_buf
->salt
;
11934 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11935 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11936 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11937 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11939 digest
[0] = byte_swap_32 (digest
[0]);
11940 digest
[1] = byte_swap_32 (digest
[1]);
11941 digest
[2] = byte_swap_32 (digest
[2]);
11942 digest
[3] = byte_swap_32 (digest
[3]);
11944 digest
[0] -= MD4M_A
;
11945 digest
[1] -= MD4M_B
;
11946 digest
[2] -= MD4M_C
;
11947 digest
[3] -= MD4M_D
;
11949 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11951 uint salt_len
= input_len
- 32 - 1;
11953 char *salt_buf
= input_buf
+ 32 + 1;
11955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11957 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11959 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11961 salt
->salt_len
= salt_len
;
11963 return (PARSER_OK
);
11966 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11968 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11970 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11974 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11977 u32
*digest
= (u32
*) hash_buf
->digest
;
11979 salt_t
*salt
= hash_buf
->salt
;
11981 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11982 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11983 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11984 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11986 digest
[0] = byte_swap_32 (digest
[0]);
11987 digest
[1] = byte_swap_32 (digest
[1]);
11988 digest
[2] = byte_swap_32 (digest
[2]);
11989 digest
[3] = byte_swap_32 (digest
[3]);
11991 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11993 uint salt_len
= input_len
- 32 - 1;
11995 char *salt_buf
= input_buf
+ 32 + 1;
11997 uint salt_pc_block
[16] = { 0 };
11999 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12001 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12003 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12005 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12007 salt_pc_block
[14] = salt_len
* 8;
12009 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12011 md5_64 (salt_pc_block
, salt_pc_digest
);
12013 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12014 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12015 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12016 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12018 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12020 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12022 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12024 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12025 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12026 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12027 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12029 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12031 return (PARSER_OK
);
12034 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12036 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12038 u32
*digest
= (u32
*) hash_buf
->digest
;
12040 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12041 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12042 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12043 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12044 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12046 digest
[0] -= SHA1M_A
;
12047 digest
[1] -= SHA1M_B
;
12048 digest
[2] -= SHA1M_C
;
12049 digest
[3] -= SHA1M_D
;
12050 digest
[4] -= SHA1M_E
;
12052 return (PARSER_OK
);
12055 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12057 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12059 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12061 u32
*digest
= (u32
*) hash_buf
->digest
;
12065 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12066 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12067 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12068 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12071 return (PARSER_OK
);
12074 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12076 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12078 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12082 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12085 u32
*digest
= (u32
*) hash_buf
->digest
;
12087 salt_t
*salt
= hash_buf
->salt
;
12089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12093 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12095 digest
[0] -= SHA1M_A
;
12096 digest
[1] -= SHA1M_B
;
12097 digest
[2] -= SHA1M_C
;
12098 digest
[3] -= SHA1M_D
;
12099 digest
[4] -= SHA1M_E
;
12101 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12103 uint salt_len
= input_len
- 40 - 1;
12105 char *salt_buf
= input_buf
+ 40 + 1;
12107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12113 salt
->salt_len
= salt_len
;
12115 return (PARSER_OK
);
12118 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12120 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12122 u32
*digest
= (u32
*) hash_buf
->digest
;
12124 salt_t
*salt
= hash_buf
->salt
;
12126 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12128 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12129 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12130 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12131 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12132 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12134 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12136 uint salt_len
= input_len
- 40 - 1;
12138 char *salt_buf
= input_buf
+ 40 + 1;
12140 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12142 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12144 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12146 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12149 pstoken
->salt_len
= salt_len
/ 2;
12151 /* some fake salt for the sorting mechanisms */
12153 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12154 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12155 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12156 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12157 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12158 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12159 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12160 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12162 salt
->salt_len
= 32;
12164 /* we need to check if we can precompute some of the data --
12165 this is possible since the scheme is badly designed */
12167 pstoken
->pc_digest
[0] = SHA1M_A
;
12168 pstoken
->pc_digest
[1] = SHA1M_B
;
12169 pstoken
->pc_digest
[2] = SHA1M_C
;
12170 pstoken
->pc_digest
[3] = SHA1M_D
;
12171 pstoken
->pc_digest
[4] = SHA1M_E
;
12173 pstoken
->pc_offset
= 0;
12175 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12179 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12180 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12181 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12182 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12183 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12184 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12185 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12186 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12187 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12188 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12189 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12190 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12191 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12192 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12193 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12194 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12196 sha1_64 (w
, pstoken
->pc_digest
);
12198 pstoken
->pc_offset
+= 16;
12201 return (PARSER_OK
);
12204 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12206 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12208 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12210 u32
*digest
= (u32
*) hash_buf
->digest
;
12212 u8 tmp_buf
[100] = { 0 };
12214 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12216 memcpy (digest
, tmp_buf
, 20);
12218 digest
[0] = byte_swap_32 (digest
[0]);
12219 digest
[1] = byte_swap_32 (digest
[1]);
12220 digest
[2] = byte_swap_32 (digest
[2]);
12221 digest
[3] = byte_swap_32 (digest
[3]);
12222 digest
[4] = byte_swap_32 (digest
[4]);
12224 digest
[0] -= SHA1M_A
;
12225 digest
[1] -= SHA1M_B
;
12226 digest
[2] -= SHA1M_C
;
12227 digest
[3] -= SHA1M_D
;
12228 digest
[4] -= SHA1M_E
;
12230 return (PARSER_OK
);
12233 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12235 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12237 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12239 u32
*digest
= (u32
*) hash_buf
->digest
;
12241 salt_t
*salt
= hash_buf
->salt
;
12243 u8 tmp_buf
[100] = { 0 };
12245 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12247 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12249 memcpy (digest
, tmp_buf
, 20);
12251 int salt_len
= tmp_len
- 20;
12253 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12255 salt
->salt_len
= salt_len
;
12257 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12259 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12261 char *ptr
= (char *) salt
->salt_buf
;
12263 ptr
[salt
->salt_len
] = 0x80;
12266 digest
[0] = byte_swap_32 (digest
[0]);
12267 digest
[1] = byte_swap_32 (digest
[1]);
12268 digest
[2] = byte_swap_32 (digest
[2]);
12269 digest
[3] = byte_swap_32 (digest
[3]);
12270 digest
[4] = byte_swap_32 (digest
[4]);
12272 digest
[0] -= SHA1M_A
;
12273 digest
[1] -= SHA1M_B
;
12274 digest
[2] -= SHA1M_C
;
12275 digest
[3] -= SHA1M_D
;
12276 digest
[4] -= SHA1M_E
;
12278 return (PARSER_OK
);
12281 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12283 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12285 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12287 u32
*digest
= (u32
*) hash_buf
->digest
;
12289 salt_t
*salt
= hash_buf
->salt
;
12291 char *salt_buf
= input_buf
+ 6;
12295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12297 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12301 salt
->salt_len
= salt_len
;
12303 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12305 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12306 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12307 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12308 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12309 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12311 digest
[0] -= SHA1M_A
;
12312 digest
[1] -= SHA1M_B
;
12313 digest
[2] -= SHA1M_C
;
12314 digest
[3] -= SHA1M_D
;
12315 digest
[4] -= SHA1M_E
;
12317 return (PARSER_OK
);
12320 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12322 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12324 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12326 u32
*digest
= (u32
*) hash_buf
->digest
;
12328 salt_t
*salt
= hash_buf
->salt
;
12330 char *salt_buf
= input_buf
+ 6;
12334 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12336 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12338 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12340 salt
->salt_len
= salt_len
;
12342 char *hash_pos
= input_buf
+ 6 + 8;
12344 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12345 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12346 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12347 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12348 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12350 digest
[0] -= SHA1M_A
;
12351 digest
[1] -= SHA1M_B
;
12352 digest
[2] -= SHA1M_C
;
12353 digest
[3] -= SHA1M_D
;
12354 digest
[4] -= SHA1M_E
;
12356 return (PARSER_OK
);
12359 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12361 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12363 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12365 u64
*digest
= (u64
*) hash_buf
->digest
;
12367 salt_t
*salt
= hash_buf
->salt
;
12369 char *salt_buf
= input_buf
+ 6;
12373 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12375 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12377 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12379 salt
->salt_len
= salt_len
;
12381 char *hash_pos
= input_buf
+ 6 + 8;
12383 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12384 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12385 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12386 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12387 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12388 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12389 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12390 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12392 digest
[0] -= SHA512M_A
;
12393 digest
[1] -= SHA512M_B
;
12394 digest
[2] -= SHA512M_C
;
12395 digest
[3] -= SHA512M_D
;
12396 digest
[4] -= SHA512M_E
;
12397 digest
[5] -= SHA512M_F
;
12398 digest
[6] -= SHA512M_G
;
12399 digest
[7] -= SHA512M_H
;
12401 return (PARSER_OK
);
12404 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12408 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12412 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12415 u32
*digest
= (u32
*) hash_buf
->digest
;
12417 salt_t
*salt
= hash_buf
->salt
;
12419 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12420 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12424 digest
[0] = byte_swap_32 (digest
[0]);
12425 digest
[1] = byte_swap_32 (digest
[1]);
12427 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12429 uint salt_len
= input_len
- 16 - 1;
12431 char *salt_buf
= input_buf
+ 16 + 1;
12433 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12435 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12437 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12439 salt
->salt_len
= salt_len
;
12441 return (PARSER_OK
);
12444 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12446 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12448 u32
*digest
= (u32
*) hash_buf
->digest
;
12450 salt_t
*salt
= hash_buf
->salt
;
12452 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12453 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12454 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12455 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12456 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12458 digest
[0] -= SHA1M_A
;
12459 digest
[1] -= SHA1M_B
;
12460 digest
[2] -= SHA1M_C
;
12461 digest
[3] -= SHA1M_D
;
12462 digest
[4] -= SHA1M_E
;
12464 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12466 uint salt_len
= input_len
- 40 - 1;
12468 char *salt_buf
= input_buf
+ 40 + 1;
12470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12472 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12476 salt
->salt_len
= salt_len
;
12478 return (PARSER_OK
);
12481 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12483 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12485 u32
*digest
= (u32
*) hash_buf
->digest
;
12487 salt_t
*salt
= hash_buf
->salt
;
12489 char *hash_pos
= input_buf
;
12491 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12492 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12493 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12494 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12495 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12496 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12497 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12498 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12499 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12500 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12501 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12502 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12503 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12504 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12505 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12506 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12508 char *salt_pos
= input_buf
+ 128;
12510 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12511 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12512 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12513 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12515 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12516 salt
->salt_len
= 16;
12518 return (PARSER_OK
);
12521 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12523 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12525 u32
*digest
= (u32
*) hash_buf
->digest
;
12527 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12528 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12529 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12530 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12531 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12532 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12533 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12534 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12536 digest
[0] -= SHA256M_A
;
12537 digest
[1] -= SHA256M_B
;
12538 digest
[2] -= SHA256M_C
;
12539 digest
[3] -= SHA256M_D
;
12540 digest
[4] -= SHA256M_E
;
12541 digest
[5] -= SHA256M_F
;
12542 digest
[6] -= SHA256M_G
;
12543 digest
[7] -= SHA256M_H
;
12545 return (PARSER_OK
);
12548 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12550 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12552 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12556 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12559 u32
*digest
= (u32
*) hash_buf
->digest
;
12561 salt_t
*salt
= hash_buf
->salt
;
12563 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12564 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12565 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12566 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12567 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12568 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12569 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12570 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12572 digest
[0] -= SHA256M_A
;
12573 digest
[1] -= SHA256M_B
;
12574 digest
[2] -= SHA256M_C
;
12575 digest
[3] -= SHA256M_D
;
12576 digest
[4] -= SHA256M_E
;
12577 digest
[5] -= SHA256M_F
;
12578 digest
[6] -= SHA256M_G
;
12579 digest
[7] -= SHA256M_H
;
12581 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12583 uint salt_len
= input_len
- 64 - 1;
12585 char *salt_buf
= input_buf
+ 64 + 1;
12587 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12589 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12591 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12593 salt
->salt_len
= salt_len
;
12595 return (PARSER_OK
);
12598 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12600 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12602 u64
*digest
= (u64
*) hash_buf
->digest
;
12604 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12605 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12606 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12607 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12608 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12609 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12613 digest
[0] -= SHA384M_A
;
12614 digest
[1] -= SHA384M_B
;
12615 digest
[2] -= SHA384M_C
;
12616 digest
[3] -= SHA384M_D
;
12617 digest
[4] -= SHA384M_E
;
12618 digest
[5] -= SHA384M_F
;
12622 return (PARSER_OK
);
12625 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12627 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12629 u64
*digest
= (u64
*) hash_buf
->digest
;
12631 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12632 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12633 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12634 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12635 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12636 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12637 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12638 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12640 digest
[0] -= SHA512M_A
;
12641 digest
[1] -= SHA512M_B
;
12642 digest
[2] -= SHA512M_C
;
12643 digest
[3] -= SHA512M_D
;
12644 digest
[4] -= SHA512M_E
;
12645 digest
[5] -= SHA512M_F
;
12646 digest
[6] -= SHA512M_G
;
12647 digest
[7] -= SHA512M_H
;
12649 return (PARSER_OK
);
12652 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12654 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12656 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12660 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12663 u64
*digest
= (u64
*) hash_buf
->digest
;
12665 salt_t
*salt
= hash_buf
->salt
;
12667 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12668 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12669 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12670 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12671 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12672 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12673 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12674 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12676 digest
[0] -= SHA512M_A
;
12677 digest
[1] -= SHA512M_B
;
12678 digest
[2] -= SHA512M_C
;
12679 digest
[3] -= SHA512M_D
;
12680 digest
[4] -= SHA512M_E
;
12681 digest
[5] -= SHA512M_F
;
12682 digest
[6] -= SHA512M_G
;
12683 digest
[7] -= SHA512M_H
;
12685 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12687 uint salt_len
= input_len
- 128 - 1;
12689 char *salt_buf
= input_buf
+ 128 + 1;
12691 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12693 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12695 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12697 salt
->salt_len
= salt_len
;
12699 return (PARSER_OK
);
12702 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12704 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12706 u64
*digest
= (u64
*) hash_buf
->digest
;
12708 salt_t
*salt
= hash_buf
->salt
;
12710 char *salt_pos
= input_buf
+ 3;
12712 uint iterations_len
= 0;
12714 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12718 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12720 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12721 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12725 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12729 iterations_len
+= 8;
12733 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12736 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12738 char *hash_pos
= strchr (salt_pos
, '$');
12740 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12742 uint salt_len
= hash_pos
- salt_pos
;
12744 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12746 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12748 salt
->salt_len
= salt_len
;
12752 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12754 return (PARSER_OK
);
12757 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12759 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12761 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12763 u64
*digest
= (u64
*) hash_buf
->digest
;
12765 salt_t
*salt
= hash_buf
->salt
;
12767 uint keccak_mdlen
= input_len
/ 2;
12769 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12771 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12773 digest
[i
] = byte_swap_64 (digest
[i
]);
12776 salt
->keccak_mdlen
= keccak_mdlen
;
12778 return (PARSER_OK
);
12781 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12783 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12785 u32
*digest
= (u32
*) hash_buf
->digest
;
12787 salt_t
*salt
= hash_buf
->salt
;
12789 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12792 * Parse that strange long line
12797 size_t in_len
[9] = { 0 };
12799 in_off
[0] = strtok (input_buf
, ":");
12801 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12803 in_len
[0] = strlen (in_off
[0]);
12807 for (i
= 1; i
< 9; i
++)
12809 in_off
[i
] = strtok (NULL
, ":");
12811 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12813 in_len
[i
] = strlen (in_off
[i
]);
12816 char *ptr
= (char *) ikepsk
->msg_buf
;
12818 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12819 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12820 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12821 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12822 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12823 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12827 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12829 ptr
= (char *) ikepsk
->nr_buf
;
12831 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12832 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12836 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12839 * Store to database
12844 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12845 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12846 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12847 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12849 digest
[0] = byte_swap_32 (digest
[0]);
12850 digest
[1] = byte_swap_32 (digest
[1]);
12851 digest
[2] = byte_swap_32 (digest
[2]);
12852 digest
[3] = byte_swap_32 (digest
[3]);
12854 salt
->salt_len
= 32;
12856 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12857 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12858 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12859 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12860 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12861 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12862 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12863 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12865 return (PARSER_OK
);
12868 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12870 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12872 u32
*digest
= (u32
*) hash_buf
->digest
;
12874 salt_t
*salt
= hash_buf
->salt
;
12876 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12879 * Parse that strange long line
12884 size_t in_len
[9] = { 0 };
12886 in_off
[0] = strtok (input_buf
, ":");
12888 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12890 in_len
[0] = strlen (in_off
[0]);
12894 for (i
= 1; i
< 9; i
++)
12896 in_off
[i
] = strtok (NULL
, ":");
12898 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12900 in_len
[i
] = strlen (in_off
[i
]);
12903 char *ptr
= (char *) ikepsk
->msg_buf
;
12905 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12906 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12907 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12908 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12909 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12910 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12914 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12916 ptr
= (char *) ikepsk
->nr_buf
;
12918 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12919 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12923 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12926 * Store to database
12931 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12932 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12933 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12934 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12935 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12937 salt
->salt_len
= 32;
12939 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12940 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12941 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12942 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12943 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12944 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12945 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12946 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12948 return (PARSER_OK
);
12951 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12953 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12955 u32
*digest
= (u32
*) hash_buf
->digest
;
12957 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12958 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12959 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12960 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12961 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12963 digest
[0] = byte_swap_32 (digest
[0]);
12964 digest
[1] = byte_swap_32 (digest
[1]);
12965 digest
[2] = byte_swap_32 (digest
[2]);
12966 digest
[3] = byte_swap_32 (digest
[3]);
12967 digest
[4] = byte_swap_32 (digest
[4]);
12969 return (PARSER_OK
);
12972 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12974 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12976 u32
*digest
= (u32
*) hash_buf
->digest
;
12978 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12979 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12980 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12981 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12982 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12983 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12984 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12985 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12986 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12987 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12988 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12989 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12990 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12991 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12992 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12993 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12995 return (PARSER_OK
);
12998 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13000 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13002 u32
*digest
= (u32
*) hash_buf
->digest
;
13004 salt_t
*salt
= hash_buf
->salt
;
13006 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13007 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13008 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13009 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13010 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13012 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13014 uint salt_len
= input_len
- 40 - 1;
13016 char *salt_buf
= input_buf
+ 40 + 1;
13018 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13020 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13022 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13024 salt
->salt_len
= salt_len
;
13026 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13028 return (PARSER_OK
);
13031 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13033 u32
*digest
= (u32
*) hash_buf
->digest
;
13035 salt_t
*salt
= hash_buf
->salt
;
13037 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13039 if (input_len
== 0)
13041 log_error ("TrueCrypt container not specified");
13046 FILE *fp
= fopen (input_buf
, "rb");
13050 log_error ("%s: %s", input_buf
, strerror (errno
));
13055 char buf
[512] = { 0 };
13057 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13061 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13063 memcpy (tc
->salt_buf
, buf
, 64);
13065 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13067 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13069 salt
->salt_len
= 4;
13071 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13073 tc
->signature
= 0x45555254; // "TRUE"
13075 digest
[0] = tc
->data_buf
[0];
13077 return (PARSER_OK
);
13080 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13082 u32
*digest
= (u32
*) hash_buf
->digest
;
13084 salt_t
*salt
= hash_buf
->salt
;
13086 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13088 if (input_len
== 0)
13090 log_error ("TrueCrypt container not specified");
13095 FILE *fp
= fopen (input_buf
, "rb");
13099 log_error ("%s: %s", input_buf
, strerror (errno
));
13104 char buf
[512] = { 0 };
13106 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13110 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13112 memcpy (tc
->salt_buf
, buf
, 64);
13114 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13116 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13118 salt
->salt_len
= 4;
13120 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13122 tc
->signature
= 0x45555254; // "TRUE"
13124 digest
[0] = tc
->data_buf
[0];
13126 return (PARSER_OK
);
13129 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13131 u32
*digest
= (u32
*) hash_buf
->digest
;
13133 salt_t
*salt
= hash_buf
->salt
;
13135 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13137 if (input_len
== 0)
13139 log_error ("VeraCrypt container not specified");
13144 FILE *fp
= fopen (input_buf
, "rb");
13148 log_error ("%s: %s", input_buf
, strerror (errno
));
13153 char buf
[512] = { 0 };
13155 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13159 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13161 memcpy (tc
->salt_buf
, buf
, 64);
13163 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13165 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13167 salt
->salt_len
= 4;
13169 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13171 tc
->signature
= 0x41524556; // "VERA"
13173 digest
[0] = tc
->data_buf
[0];
13175 return (PARSER_OK
);
13178 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13180 u32
*digest
= (u32
*) hash_buf
->digest
;
13182 salt_t
*salt
= hash_buf
->salt
;
13184 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13186 if (input_len
== 0)
13188 log_error ("VeraCrypt container not specified");
13193 FILE *fp
= fopen (input_buf
, "rb");
13197 log_error ("%s: %s", input_buf
, strerror (errno
));
13202 char buf
[512] = { 0 };
13204 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13208 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13210 memcpy (tc
->salt_buf
, buf
, 64);
13212 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13214 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13216 salt
->salt_len
= 4;
13218 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13220 tc
->signature
= 0x41524556; // "VERA"
13222 digest
[0] = tc
->data_buf
[0];
13224 return (PARSER_OK
);
13227 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13229 u32
*digest
= (u32
*) hash_buf
->digest
;
13231 salt_t
*salt
= hash_buf
->salt
;
13233 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13235 if (input_len
== 0)
13237 log_error ("VeraCrypt container not specified");
13242 FILE *fp
= fopen (input_buf
, "rb");
13246 log_error ("%s: %s", input_buf
, strerror (errno
));
13251 char buf
[512] = { 0 };
13253 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13257 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13259 memcpy (tc
->salt_buf
, buf
, 64);
13261 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13263 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13265 salt
->salt_len
= 4;
13267 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13269 tc
->signature
= 0x41524556; // "VERA"
13271 digest
[0] = tc
->data_buf
[0];
13273 return (PARSER_OK
);
13276 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13278 u32
*digest
= (u32
*) hash_buf
->digest
;
13280 salt_t
*salt
= hash_buf
->salt
;
13282 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13284 if (input_len
== 0)
13286 log_error ("VeraCrypt container not specified");
13291 FILE *fp
= fopen (input_buf
, "rb");
13295 log_error ("%s: %s", input_buf
, strerror (errno
));
13300 char buf
[512] = { 0 };
13302 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13306 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13308 memcpy (tc
->salt_buf
, buf
, 64);
13310 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13312 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13314 salt
->salt_len
= 4;
13316 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13318 tc
->signature
= 0x41524556; // "VERA"
13320 digest
[0] = tc
->data_buf
[0];
13322 return (PARSER_OK
);
13325 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13327 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13329 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13331 u32
*digest
= (u32
*) hash_buf
->digest
;
13333 salt_t
*salt
= hash_buf
->salt
;
13335 char *salt_pos
= input_buf
+ 6;
13337 char *hash_pos
= strchr (salt_pos
, '$');
13339 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13341 uint salt_len
= hash_pos
- salt_pos
;
13343 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13345 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13347 salt
->salt_len
= salt_len
;
13349 salt
->salt_iter
= 1000;
13353 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13355 return (PARSER_OK
);
13358 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13360 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13362 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13364 u32
*digest
= (u32
*) hash_buf
->digest
;
13366 salt_t
*salt
= hash_buf
->salt
;
13368 char *iter_pos
= input_buf
+ 7;
13370 char *salt_pos
= strchr (iter_pos
, '$');
13372 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13376 char *hash_pos
= strchr (salt_pos
, '$');
13378 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13380 uint salt_len
= hash_pos
- salt_pos
;
13382 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13384 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13386 salt
->salt_len
= salt_len
;
13388 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13390 salt
->salt_sign
[0] = atoi (salt_iter
);
13392 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13396 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13398 digest
[0] = byte_swap_32 (digest
[0]);
13399 digest
[1] = byte_swap_32 (digest
[1]);
13400 digest
[2] = byte_swap_32 (digest
[2]);
13401 digest
[3] = byte_swap_32 (digest
[3]);
13402 digest
[4] = byte_swap_32 (digest
[4]);
13404 return (PARSER_OK
);
13407 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13409 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13411 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13413 u32
*digest
= (u32
*) hash_buf
->digest
;
13415 salt_t
*salt
= hash_buf
->salt
;
13417 char *iter_pos
= input_buf
+ 9;
13419 char *salt_pos
= strchr (iter_pos
, '$');
13421 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13425 char *hash_pos
= strchr (salt_pos
, '$');
13427 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13429 uint salt_len
= hash_pos
- salt_pos
;
13431 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13433 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13435 salt
->salt_len
= salt_len
;
13437 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13439 salt
->salt_sign
[0] = atoi (salt_iter
);
13441 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13445 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13447 digest
[0] = byte_swap_32 (digest
[0]);
13448 digest
[1] = byte_swap_32 (digest
[1]);
13449 digest
[2] = byte_swap_32 (digest
[2]);
13450 digest
[3] = byte_swap_32 (digest
[3]);
13451 digest
[4] = byte_swap_32 (digest
[4]);
13452 digest
[5] = byte_swap_32 (digest
[5]);
13453 digest
[6] = byte_swap_32 (digest
[6]);
13454 digest
[7] = byte_swap_32 (digest
[7]);
13456 return (PARSER_OK
);
13459 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13461 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13463 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13465 u64
*digest
= (u64
*) hash_buf
->digest
;
13467 salt_t
*salt
= hash_buf
->salt
;
13469 char *iter_pos
= input_buf
+ 9;
13471 char *salt_pos
= strchr (iter_pos
, '$');
13473 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13477 char *hash_pos
= strchr (salt_pos
, '$');
13479 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13481 uint salt_len
= hash_pos
- salt_pos
;
13483 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13485 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13487 salt
->salt_len
= salt_len
;
13489 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13491 salt
->salt_sign
[0] = atoi (salt_iter
);
13493 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13497 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13499 digest
[0] = byte_swap_64 (digest
[0]);
13500 digest
[1] = byte_swap_64 (digest
[1]);
13501 digest
[2] = byte_swap_64 (digest
[2]);
13502 digest
[3] = byte_swap_64 (digest
[3]);
13503 digest
[4] = byte_swap_64 (digest
[4]);
13504 digest
[5] = byte_swap_64 (digest
[5]);
13505 digest
[6] = byte_swap_64 (digest
[6]);
13506 digest
[7] = byte_swap_64 (digest
[7]);
13508 return (PARSER_OK
);
13511 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13513 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13515 u32
*digest
= (u32
*) hash_buf
->digest
;
13517 salt_t
*salt
= hash_buf
->salt
;
13519 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13525 char *iterations_pos
= input_buf
;
13527 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13529 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13531 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13533 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13537 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13539 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13541 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13543 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13545 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13547 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13552 * pbkdf2 iterations
13555 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13558 * handle salt encoding
13561 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13563 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13565 const char p0
= saltbuf_pos
[i
+ 0];
13566 const char p1
= saltbuf_pos
[i
+ 1];
13568 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13569 | hex_convert (p0
) << 4;
13572 salt
->salt_len
= saltbuf_len
/ 2;
13575 * handle cipher encoding
13578 uint
*tmp
= (uint
*) mymalloc (32);
13580 char *cipherbuf_ptr
= (char *) tmp
;
13582 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13584 const char p0
= cipherbuf_pos
[i
+ 0];
13585 const char p1
= cipherbuf_pos
[i
+ 1];
13587 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13588 | hex_convert (p0
) << 4;
13591 // iv is stored at salt_buf 4 (length 16)
13592 // data is stored at salt_buf 8 (length 16)
13594 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13595 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13596 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13597 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13599 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13600 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13601 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13602 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13606 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13608 const char p0
= cipherbuf_pos
[j
+ 0];
13609 const char p1
= cipherbuf_pos
[j
+ 1];
13611 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13612 | hex_convert (p0
) << 4;
13619 digest
[0] = 0x10101010;
13620 digest
[1] = 0x10101010;
13621 digest
[2] = 0x10101010;
13622 digest
[3] = 0x10101010;
13624 return (PARSER_OK
);
13627 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13629 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13631 u32
*digest
= (u32
*) hash_buf
->digest
;
13633 salt_t
*salt
= hash_buf
->salt
;
13635 char *hashbuf_pos
= input_buf
;
13637 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13639 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13641 uint hash_len
= iterations_pos
- hashbuf_pos
;
13643 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13647 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13649 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13651 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13655 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13657 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13659 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13661 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13663 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13665 salt
->salt_len
= salt_len
;
13667 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13669 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13670 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13671 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13672 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13674 return (PARSER_OK
);
13677 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13679 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13681 u32
*digest
= (u32
*) hash_buf
->digest
;
13683 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13684 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13685 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13686 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13687 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13688 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13689 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13690 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13692 digest
[0] = byte_swap_32 (digest
[0]);
13693 digest
[1] = byte_swap_32 (digest
[1]);
13694 digest
[2] = byte_swap_32 (digest
[2]);
13695 digest
[3] = byte_swap_32 (digest
[3]);
13696 digest
[4] = byte_swap_32 (digest
[4]);
13697 digest
[5] = byte_swap_32 (digest
[5]);
13698 digest
[6] = byte_swap_32 (digest
[6]);
13699 digest
[7] = byte_swap_32 (digest
[7]);
13701 return (PARSER_OK
);
13704 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13706 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13708 u32
*digest
= (u32
*) hash_buf
->digest
;
13710 salt_t
*salt
= hash_buf
->salt
;
13712 char *salt_pos
= input_buf
+ 3;
13714 uint iterations_len
= 0;
13716 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13720 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13722 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13723 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13727 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13731 iterations_len
+= 8;
13735 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13738 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13740 char *hash_pos
= strchr (salt_pos
, '$');
13742 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13744 uint salt_len
= hash_pos
- salt_pos
;
13746 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13748 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13750 salt
->salt_len
= salt_len
;
13754 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13756 return (PARSER_OK
);
13759 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13761 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13763 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13765 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13767 u64
*digest
= (u64
*) hash_buf
->digest
;
13769 salt_t
*salt
= hash_buf
->salt
;
13771 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13773 char *iter_pos
= input_buf
+ 4;
13775 char *salt_pos
= strchr (iter_pos
, '$');
13777 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13781 char *hash_pos
= strchr (salt_pos
, '$');
13783 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13785 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13789 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13790 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13791 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13792 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13793 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13794 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13795 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13796 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13798 uint salt_len
= hash_pos
- salt_pos
- 1;
13800 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13802 salt
->salt_len
= salt_len
/ 2;
13804 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13805 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13806 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13807 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13808 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13809 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13810 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13811 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13813 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13814 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13815 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13816 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13817 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13818 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13819 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13820 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13821 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13822 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13824 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13826 salt
->salt_iter
= atoi (iter_pos
) - 1;
13828 return (PARSER_OK
);
13831 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13833 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13835 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13837 u32
*digest
= (u32
*) hash_buf
->digest
;
13839 salt_t
*salt
= hash_buf
->salt
;
13841 char *salt_pos
= input_buf
+ 14;
13843 char *hash_pos
= strchr (salt_pos
, '*');
13845 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13849 uint salt_len
= hash_pos
- salt_pos
- 1;
13851 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13853 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13855 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13857 salt
->salt_len
= salt_len
;
13859 u8 tmp_buf
[100] = { 0 };
13861 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13863 memcpy (digest
, tmp_buf
, 32);
13865 digest
[0] = byte_swap_32 (digest
[0]);
13866 digest
[1] = byte_swap_32 (digest
[1]);
13867 digest
[2] = byte_swap_32 (digest
[2]);
13868 digest
[3] = byte_swap_32 (digest
[3]);
13869 digest
[4] = byte_swap_32 (digest
[4]);
13870 digest
[5] = byte_swap_32 (digest
[5]);
13871 digest
[6] = byte_swap_32 (digest
[6]);
13872 digest
[7] = byte_swap_32 (digest
[7]);
13874 digest
[0] -= SHA256M_A
;
13875 digest
[1] -= SHA256M_B
;
13876 digest
[2] -= SHA256M_C
;
13877 digest
[3] -= SHA256M_D
;
13878 digest
[4] -= SHA256M_E
;
13879 digest
[5] -= SHA256M_F
;
13880 digest
[6] -= SHA256M_G
;
13881 digest
[7] -= SHA256M_H
;
13883 return (PARSER_OK
);
13886 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13888 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13890 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13892 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13894 u64
*digest
= (u64
*) hash_buf
->digest
;
13896 salt_t
*salt
= hash_buf
->salt
;
13898 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13900 char *iter_pos
= input_buf
+ 19;
13902 char *salt_pos
= strchr (iter_pos
, '.');
13904 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13908 char *hash_pos
= strchr (salt_pos
, '.');
13910 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13912 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13916 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13917 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13918 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13919 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13920 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13921 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13922 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13923 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13925 uint salt_len
= hash_pos
- salt_pos
- 1;
13929 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13933 for (i
= 0; i
< salt_len
; i
++)
13935 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13938 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13939 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13941 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13943 salt
->salt_len
= salt_len
;
13945 salt
->salt_iter
= atoi (iter_pos
) - 1;
13947 return (PARSER_OK
);
13950 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13952 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13954 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13956 u64
*digest
= (u64
*) hash_buf
->digest
;
13958 salt_t
*salt
= hash_buf
->salt
;
13960 u8 tmp_buf
[120] = { 0 };
13962 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13964 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13966 memcpy (digest
, tmp_buf
, 64);
13968 digest
[0] = byte_swap_64 (digest
[0]);
13969 digest
[1] = byte_swap_64 (digest
[1]);
13970 digest
[2] = byte_swap_64 (digest
[2]);
13971 digest
[3] = byte_swap_64 (digest
[3]);
13972 digest
[4] = byte_swap_64 (digest
[4]);
13973 digest
[5] = byte_swap_64 (digest
[5]);
13974 digest
[6] = byte_swap_64 (digest
[6]);
13975 digest
[7] = byte_swap_64 (digest
[7]);
13977 digest
[0] -= SHA512M_A
;
13978 digest
[1] -= SHA512M_B
;
13979 digest
[2] -= SHA512M_C
;
13980 digest
[3] -= SHA512M_D
;
13981 digest
[4] -= SHA512M_E
;
13982 digest
[5] -= SHA512M_F
;
13983 digest
[6] -= SHA512M_G
;
13984 digest
[7] -= SHA512M_H
;
13986 int salt_len
= tmp_len
- 64;
13988 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13990 salt
->salt_len
= salt_len
;
13992 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13994 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13996 char *ptr
= (char *) salt
->salt_buf
;
13998 ptr
[salt
->salt_len
] = 0x80;
14001 return (PARSER_OK
);
14004 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14006 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14008 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14012 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14015 u32
*digest
= (u32
*) hash_buf
->digest
;
14017 salt_t
*salt
= hash_buf
->salt
;
14019 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14020 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14021 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14022 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14024 digest
[0] = byte_swap_32 (digest
[0]);
14025 digest
[1] = byte_swap_32 (digest
[1]);
14026 digest
[2] = byte_swap_32 (digest
[2]);
14027 digest
[3] = byte_swap_32 (digest
[3]);
14029 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14031 uint salt_len
= input_len
- 32 - 1;
14033 char *salt_buf
= input_buf
+ 32 + 1;
14035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14037 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14039 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14041 salt
->salt_len
= salt_len
;
14043 return (PARSER_OK
);
14046 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14048 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14050 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14054 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14057 u32
*digest
= (u32
*) hash_buf
->digest
;
14059 salt_t
*salt
= hash_buf
->salt
;
14061 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14062 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14063 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14064 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14065 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14067 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14069 uint salt_len
= input_len
- 40 - 1;
14071 char *salt_buf
= input_buf
+ 40 + 1;
14073 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14075 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14077 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14079 salt
->salt_len
= salt_len
;
14081 return (PARSER_OK
);
14084 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14086 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14088 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14092 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14095 u32
*digest
= (u32
*) hash_buf
->digest
;
14097 salt_t
*salt
= hash_buf
->salt
;
14099 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14100 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14101 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14102 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14103 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14104 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14105 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14106 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14108 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14110 uint salt_len
= input_len
- 64 - 1;
14112 char *salt_buf
= input_buf
+ 64 + 1;
14114 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14116 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14118 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14120 salt
->salt_len
= salt_len
;
14122 return (PARSER_OK
);
14125 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14127 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14129 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14133 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14136 u64
*digest
= (u64
*) hash_buf
->digest
;
14138 salt_t
*salt
= hash_buf
->salt
;
14140 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14141 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14142 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14143 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14144 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14145 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14146 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14147 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14149 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14151 uint salt_len
= input_len
- 128 - 1;
14153 char *salt_buf
= input_buf
+ 128 + 1;
14155 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14157 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14159 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14161 salt
->salt_len
= salt_len
;
14163 return (PARSER_OK
);
14166 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14168 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14170 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14172 u32
*digest
= (u32
*) hash_buf
->digest
;
14174 salt_t
*salt
= hash_buf
->salt
;
14176 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14182 char *user_pos
= input_buf
+ 10 + 1;
14184 char *realm_pos
= strchr (user_pos
, '$');
14186 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14188 uint user_len
= realm_pos
- user_pos
;
14190 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14194 char *salt_pos
= strchr (realm_pos
, '$');
14196 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14198 uint realm_len
= salt_pos
- realm_pos
;
14200 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14204 char *data_pos
= strchr (salt_pos
, '$');
14206 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14208 uint salt_len
= data_pos
- salt_pos
;
14210 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14214 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14216 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14222 memcpy (krb5pa
->user
, user_pos
, user_len
);
14223 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14224 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14226 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14228 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14230 const char p0
= data_pos
[i
+ 0];
14231 const char p1
= data_pos
[i
+ 1];
14233 *timestamp_ptr
++ = hex_convert (p1
) << 0
14234 | hex_convert (p0
) << 4;
14237 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14239 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14241 const char p0
= data_pos
[i
+ 0];
14242 const char p1
= data_pos
[i
+ 1];
14244 *checksum_ptr
++ = hex_convert (p1
) << 0
14245 | hex_convert (p0
) << 4;
14249 * copy some data to generic buffers to make sorting happy
14252 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14253 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14254 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14255 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14256 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14257 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14258 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14259 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14260 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14262 salt
->salt_len
= 36;
14264 digest
[0] = krb5pa
->checksum
[0];
14265 digest
[1] = krb5pa
->checksum
[1];
14266 digest
[2] = krb5pa
->checksum
[2];
14267 digest
[3] = krb5pa
->checksum
[3];
14269 return (PARSER_OK
);
14272 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14274 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14276 u32
*digest
= (u32
*) hash_buf
->digest
;
14278 salt_t
*salt
= hash_buf
->salt
;
14284 char *salt_pos
= input_buf
;
14286 char *hash_pos
= strchr (salt_pos
, '$');
14288 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14290 uint salt_len
= hash_pos
- salt_pos
;
14292 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14296 uint hash_len
= input_len
- 1 - salt_len
;
14298 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14306 for (uint i
= 0; i
< salt_len
; i
++)
14308 if (salt_pos
[i
] == ' ') continue;
14313 // SAP user names cannot be longer than 12 characters
14314 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14316 // SAP user name cannot start with ! or ?
14317 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14323 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14325 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14327 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14329 salt
->salt_len
= salt_len
;
14331 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14332 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14336 digest
[0] = byte_swap_32 (digest
[0]);
14337 digest
[1] = byte_swap_32 (digest
[1]);
14339 return (PARSER_OK
);
14342 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14344 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14346 u32
*digest
= (u32
*) hash_buf
->digest
;
14348 salt_t
*salt
= hash_buf
->salt
;
14354 char *salt_pos
= input_buf
;
14356 char *hash_pos
= strchr (salt_pos
, '$');
14358 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14360 uint salt_len
= hash_pos
- salt_pos
;
14362 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14366 uint hash_len
= input_len
- 1 - salt_len
;
14368 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14376 for (uint i
= 0; i
< salt_len
; i
++)
14378 if (salt_pos
[i
] == ' ') continue;
14383 // SAP user names cannot be longer than 12 characters
14384 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14385 // so far nobody complained so we stay with this because it helps in optimization
14386 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14388 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14390 // SAP user name cannot start with ! or ?
14391 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14397 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14399 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14401 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14403 salt
->salt_len
= salt_len
;
14405 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14406 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14407 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14408 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14409 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14411 return (PARSER_OK
);
14414 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14416 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14418 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14420 u64
*digest
= (u64
*) hash_buf
->digest
;
14422 salt_t
*salt
= hash_buf
->salt
;
14424 char *iter_pos
= input_buf
+ 3;
14426 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14428 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14430 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14432 salt
->salt_iter
= salt_iter
;
14434 char *salt_pos
= iter_pos
+ 1;
14438 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14440 salt
->salt_len
= salt_len
;
14442 char *hash_pos
= salt_pos
+ salt_len
;
14444 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14448 char *tmp
= (char *) salt
->salt_buf_pc
;
14450 tmp
[0] = hash_pos
[42];
14454 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14455 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14456 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14457 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14463 return (PARSER_OK
);
14466 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14468 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14470 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14472 u32
*digest
= (u32
*) hash_buf
->digest
;
14474 salt_t
*salt
= hash_buf
->salt
;
14476 char *salt_buf
= input_buf
+ 6;
14478 uint salt_len
= 16;
14480 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14482 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14484 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14486 salt
->salt_len
= salt_len
;
14488 char *hash_pos
= input_buf
+ 6 + 16;
14490 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14491 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14492 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14493 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14494 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14495 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14496 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14497 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14499 return (PARSER_OK
);
14502 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14504 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14506 u32
*digest
= (u32
*) hash_buf
->digest
;
14508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14513 return (PARSER_OK
);
14516 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14518 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14520 u32
*digest
= (u32
*) hash_buf
->digest
;
14522 salt_t
*salt
= hash_buf
->salt
;
14524 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14526 char *saltbuf_pos
= input_buf
;
14528 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14530 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14532 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14534 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14535 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14537 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14541 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14543 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14545 char *salt_ptr
= (char *) saltbuf_pos
;
14546 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14551 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14553 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14556 rakp_ptr
[j
] = 0x80;
14558 rakp
->salt_len
= j
;
14560 for (i
= 0; i
< 64; i
++)
14562 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14565 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14566 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14567 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14568 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14569 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14570 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14571 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14572 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14574 salt
->salt_len
= 32; // muss min. 32 haben
14576 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14577 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14578 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14579 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14580 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14582 return (PARSER_OK
);
14585 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14587 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14589 u32
*digest
= (u32
*) hash_buf
->digest
;
14591 salt_t
*salt
= hash_buf
->salt
;
14593 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14595 char *salt_pos
= input_buf
+ 1;
14597 memcpy (salt
->salt_buf
, salt_pos
, 8);
14599 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14600 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14602 salt
->salt_len
= 8;
14604 char *hash_pos
= salt_pos
+ 8;
14606 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14607 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14608 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14609 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14610 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14612 digest
[0] -= SHA1M_A
;
14613 digest
[1] -= SHA1M_B
;
14614 digest
[2] -= SHA1M_C
;
14615 digest
[3] -= SHA1M_D
;
14616 digest
[4] -= SHA1M_E
;
14618 return (PARSER_OK
);
14621 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14623 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14625 u32
*digest
= (u32
*) hash_buf
->digest
;
14627 salt_t
*salt
= hash_buf
->salt
;
14629 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14630 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14631 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14632 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14634 digest
[0] = byte_swap_32 (digest
[0]);
14635 digest
[1] = byte_swap_32 (digest
[1]);
14636 digest
[2] = byte_swap_32 (digest
[2]);
14637 digest
[3] = byte_swap_32 (digest
[3]);
14639 digest
[0] -= MD5M_A
;
14640 digest
[1] -= MD5M_B
;
14641 digest
[2] -= MD5M_C
;
14642 digest
[3] -= MD5M_D
;
14644 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14646 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14648 u32
*salt_buf
= salt
->salt_buf
;
14650 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14651 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14652 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14653 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14655 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14656 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14657 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14658 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14660 salt
->salt_len
= 16 + 1;
14662 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14664 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14666 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14668 return (PARSER_OK
);
14671 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14673 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14675 u32
*digest
= (u32
*) hash_buf
->digest
;
14677 salt_t
*salt
= hash_buf
->salt
;
14679 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14685 char *hashbuf_pos
= input_buf
;
14687 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14689 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14691 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14693 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14697 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14699 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14701 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14703 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14707 char *databuf_pos
= strchr (iteration_pos
, ':');
14709 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14711 const uint iteration_len
= databuf_pos
- iteration_pos
;
14713 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14714 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14716 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14718 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14719 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14725 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14726 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14727 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14728 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14729 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14730 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14731 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14732 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14736 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14738 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14740 const char p0
= saltbuf_pos
[i
+ 0];
14741 const char p1
= saltbuf_pos
[i
+ 1];
14743 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14744 | hex_convert (p0
) << 4;
14747 salt
->salt_buf
[4] = 0x01000000;
14748 salt
->salt_buf
[5] = 0x80;
14750 salt
->salt_len
= saltbuf_len
/ 2;
14754 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14758 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14760 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14762 const char p0
= databuf_pos
[i
+ 0];
14763 const char p1
= databuf_pos
[i
+ 1];
14765 *databuf_ptr
++ = hex_convert (p1
) << 0
14766 | hex_convert (p0
) << 4;
14769 *databuf_ptr
++ = 0x80;
14771 for (uint i
= 0; i
< 512; i
++)
14773 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14776 cloudkey
->data_len
= databuf_len
/ 2;
14778 return (PARSER_OK
);
14781 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14783 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14785 u32
*digest
= (u32
*) hash_buf
->digest
;
14787 salt_t
*salt
= hash_buf
->salt
;
14793 char *hashbuf_pos
= input_buf
;
14795 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14797 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14799 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14801 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14805 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14807 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14809 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14811 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14813 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14817 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14819 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14821 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14823 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14825 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14829 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14831 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14832 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14834 // ok, the plan for this algorithm is the following:
14835 // we have 2 salts here, the domain-name and a random salt
14836 // while both are used in the initial transformation,
14837 // only the random salt is used in the following iterations
14838 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14839 // and one that includes only the real salt (stored into salt_buf[]).
14840 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14842 u8 tmp_buf
[100] = { 0 };
14844 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14846 memcpy (digest
, tmp_buf
, 20);
14848 digest
[0] = byte_swap_32 (digest
[0]);
14849 digest
[1] = byte_swap_32 (digest
[1]);
14850 digest
[2] = byte_swap_32 (digest
[2]);
14851 digest
[3] = byte_swap_32 (digest
[3]);
14852 digest
[4] = byte_swap_32 (digest
[4]);
14856 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14858 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14860 char *len_ptr
= NULL
;
14862 for (uint i
= 0; i
< domainbuf_len
; i
++)
14864 if (salt_buf_pc_ptr
[i
] == '.')
14866 len_ptr
= &salt_buf_pc_ptr
[i
];
14876 salt
->salt_buf_pc
[7] = domainbuf_len
;
14880 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14882 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14884 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14886 salt
->salt_len
= salt_len
;
14890 salt
->salt_iter
= atoi (iteration_pos
);
14892 return (PARSER_OK
);
14895 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14897 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14899 u32
*digest
= (u32
*) hash_buf
->digest
;
14901 salt_t
*salt
= hash_buf
->salt
;
14903 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14904 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14905 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14906 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14907 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14909 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14911 uint salt_len
= input_len
- 40 - 1;
14913 char *salt_buf
= input_buf
+ 40 + 1;
14915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14921 salt
->salt_len
= salt_len
;
14923 return (PARSER_OK
);
14926 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14928 const u8 ascii_to_ebcdic
[] =
14930 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14931 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14932 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14933 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14934 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14935 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14936 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14937 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14938 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14939 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14940 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14941 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14942 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14943 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14944 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14945 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14948 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14950 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14952 u32
*digest
= (u32
*) hash_buf
->digest
;
14954 salt_t
*salt
= hash_buf
->salt
;
14956 char *salt_pos
= input_buf
+ 6 + 1;
14958 char *digest_pos
= strchr (salt_pos
, '*');
14960 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14962 uint salt_len
= digest_pos
- salt_pos
;
14964 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14966 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14968 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14973 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14975 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14977 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14979 salt
->salt_len
= salt_len
;
14981 for (uint i
= 0; i
< salt_len
; i
++)
14983 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14985 for (uint i
= salt_len
; i
< 8; i
++)
14987 salt_buf_pc_ptr
[i
] = 0x40;
14992 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14994 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14995 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14997 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14998 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15000 digest
[0] = byte_swap_32 (digest
[0]);
15001 digest
[1] = byte_swap_32 (digest
[1]);
15003 IP (digest
[0], digest
[1], tt
);
15005 digest
[0] = rotr32 (digest
[0], 29);
15006 digest
[1] = rotr32 (digest
[1], 29);
15010 return (PARSER_OK
);
15013 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15015 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15017 u32
*digest
= (u32
*) hash_buf
->digest
;
15019 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15020 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15021 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15022 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15024 digest
[0] = byte_swap_32 (digest
[0]);
15025 digest
[1] = byte_swap_32 (digest
[1]);
15026 digest
[2] = byte_swap_32 (digest
[2]);
15027 digest
[3] = byte_swap_32 (digest
[3]);
15029 return (PARSER_OK
);
15032 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15034 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15036 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15038 u32
*digest
= (u32
*) hash_buf
->digest
;
15040 salt_t
*salt
= hash_buf
->salt
;
15042 u8 tmp_buf
[120] = { 0 };
15044 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15046 tmp_buf
[3] += -4; // dont ask!
15048 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15050 salt
->salt_len
= 5;
15052 memcpy (digest
, tmp_buf
+ 5, 9);
15054 // yes, only 9 byte are needed to crack, but 10 to display
15056 salt
->salt_buf_pc
[7] = input_buf
[20];
15058 return (PARSER_OK
);
15061 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15063 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15065 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15067 u32
*digest
= (u32
*) hash_buf
->digest
;
15069 salt_t
*salt
= hash_buf
->salt
;
15071 u8 tmp_buf
[120] = { 0 };
15073 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15075 tmp_buf
[3] += -4; // dont ask!
15079 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15081 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)
15085 char tmp_iter_buf
[11] = { 0 };
15087 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15089 tmp_iter_buf
[10] = 0;
15091 salt
->salt_iter
= atoi (tmp_iter_buf
);
15093 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15095 return (PARSER_SALT_ITERATION
);
15098 salt
->salt_iter
--; // first round in init
15100 // 2 additional bytes for display only
15102 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15103 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15107 memcpy (digest
, tmp_buf
+ 28, 8);
15109 digest
[0] = byte_swap_32 (digest
[0]);
15110 digest
[1] = byte_swap_32 (digest
[1]);
15114 return (PARSER_OK
);
15117 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15119 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15121 u32
*digest
= (u32
*) hash_buf
->digest
;
15123 salt_t
*salt
= hash_buf
->salt
;
15125 char *salt_buf_pos
= input_buf
;
15127 char *hash_buf_pos
= salt_buf_pos
+ 6;
15129 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15130 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15131 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15132 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15133 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15134 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15135 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15136 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15138 digest
[0] -= SHA256M_A
;
15139 digest
[1] -= SHA256M_B
;
15140 digest
[2] -= SHA256M_C
;
15141 digest
[3] -= SHA256M_D
;
15142 digest
[4] -= SHA256M_E
;
15143 digest
[5] -= SHA256M_F
;
15144 digest
[6] -= SHA256M_G
;
15145 digest
[7] -= SHA256M_H
;
15147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15149 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15151 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15153 salt
->salt_len
= salt_len
;
15155 return (PARSER_OK
);
15158 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15160 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15162 u32
*digest
= (u32
*) hash_buf
->digest
;
15164 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15166 salt_t
*salt
= hash_buf
->salt
;
15168 char *salt_buf
= input_buf
+ 6;
15170 char *digest_buf
= strchr (salt_buf
, '$');
15172 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15174 uint salt_len
= digest_buf
- salt_buf
;
15176 digest_buf
++; // skip the '$' symbol
15178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15184 salt
->salt_len
= salt_len
;
15186 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15187 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15188 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15189 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15191 digest
[0] = byte_swap_32 (digest
[0]);
15192 digest
[1] = byte_swap_32 (digest
[1]);
15193 digest
[2] = byte_swap_32 (digest
[2]);
15194 digest
[3] = byte_swap_32 (digest
[3]);
15196 digest
[0] -= MD5M_A
;
15197 digest
[1] -= MD5M_B
;
15198 digest
[2] -= MD5M_C
;
15199 digest
[3] -= MD5M_D
;
15201 return (PARSER_OK
);
15204 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15206 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15208 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15210 u32
*digest
= (u32
*) hash_buf
->digest
;
15212 salt_t
*salt
= hash_buf
->salt
;
15214 char *salt_buf
= input_buf
+ 3;
15216 char *digest_buf
= strchr (salt_buf
, '$');
15218 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15220 uint salt_len
= digest_buf
- salt_buf
;
15222 digest_buf
++; // skip the '$' symbol
15224 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15226 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15228 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15230 salt_buf_ptr
[salt_len
] = 0x2d;
15232 salt
->salt_len
= salt_len
+ 1;
15234 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15235 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15236 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15237 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15239 digest
[0] = byte_swap_32 (digest
[0]);
15240 digest
[1] = byte_swap_32 (digest
[1]);
15241 digest
[2] = byte_swap_32 (digest
[2]);
15242 digest
[3] = byte_swap_32 (digest
[3]);
15244 digest
[0] -= MD5M_A
;
15245 digest
[1] -= MD5M_B
;
15246 digest
[2] -= MD5M_C
;
15247 digest
[3] -= MD5M_D
;
15249 return (PARSER_OK
);
15252 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15254 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15256 u32
*digest
= (u32
*) hash_buf
->digest
;
15258 salt_t
*salt
= hash_buf
->salt
;
15260 u8 tmp_buf
[100] = { 0 };
15262 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15264 memcpy (digest
, tmp_buf
, 20);
15266 digest
[0] = byte_swap_32 (digest
[0]);
15267 digest
[1] = byte_swap_32 (digest
[1]);
15268 digest
[2] = byte_swap_32 (digest
[2]);
15269 digest
[3] = byte_swap_32 (digest
[3]);
15270 digest
[4] = byte_swap_32 (digest
[4]);
15272 digest
[0] -= SHA1M_A
;
15273 digest
[1] -= SHA1M_B
;
15274 digest
[2] -= SHA1M_C
;
15275 digest
[3] -= SHA1M_D
;
15276 digest
[4] -= SHA1M_E
;
15278 salt
->salt_buf
[0] = 0x80;
15280 salt
->salt_len
= 0;
15282 return (PARSER_OK
);
15285 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15287 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15289 u32
*digest
= (u32
*) hash_buf
->digest
;
15291 salt_t
*salt
= hash_buf
->salt
;
15293 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15294 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15295 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15296 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15298 digest
[0] = byte_swap_32 (digest
[0]);
15299 digest
[1] = byte_swap_32 (digest
[1]);
15300 digest
[2] = byte_swap_32 (digest
[2]);
15301 digest
[3] = byte_swap_32 (digest
[3]);
15303 digest
[0] -= MD5M_A
;
15304 digest
[1] -= MD5M_B
;
15305 digest
[2] -= MD5M_C
;
15306 digest
[3] -= MD5M_D
;
15308 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15310 uint salt_len
= input_len
- 32 - 1;
15312 char *salt_buf
= input_buf
+ 32 + 1;
15314 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15316 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15318 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15321 * add static "salt" part
15324 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15328 salt
->salt_len
= salt_len
;
15330 return (PARSER_OK
);
15333 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15335 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15337 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15339 u32
*digest
= (u32
*) hash_buf
->digest
;
15341 salt_t
*salt
= hash_buf
->salt
;
15343 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15349 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15351 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15353 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15355 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15357 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15361 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15363 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15365 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15367 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15371 char *keybuf_pos
= strchr (keylen_pos
, '$');
15373 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15375 uint keylen_len
= keybuf_pos
- keylen_pos
;
15377 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15381 char *databuf_pos
= strchr (keybuf_pos
, '$');
15383 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15385 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15387 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15391 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15393 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15399 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15400 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15401 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15402 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15404 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15405 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15406 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15407 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15409 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15410 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15411 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15412 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15414 salt
->salt_len
= 16;
15415 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15417 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15419 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15422 return (PARSER_OK
);
15425 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15427 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15429 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15431 u32
*digest
= (u32
*) hash_buf
->digest
;
15433 salt_t
*salt
= hash_buf
->salt
;
15439 // first is the N salt parameter
15441 char *N_pos
= input_buf
+ 6;
15443 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15447 salt
->scrypt_N
= atoi (N_pos
);
15451 char *r_pos
= strchr (N_pos
, ':');
15453 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15457 salt
->scrypt_r
= atoi (r_pos
);
15461 char *p_pos
= strchr (r_pos
, ':');
15463 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15467 salt
->scrypt_p
= atoi (p_pos
);
15471 char *saltbuf_pos
= strchr (p_pos
, ':');
15473 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15477 char *hash_pos
= strchr (saltbuf_pos
, ':');
15479 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15485 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15487 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15489 u8 tmp_buf
[33] = { 0 };
15491 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15493 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15495 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15497 salt
->salt_len
= tmp_len
;
15498 salt
->salt_iter
= 1;
15500 // digest - base64 decode
15502 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15504 tmp_len
= input_len
- (hash_pos
- input_buf
);
15506 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15508 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15510 memcpy (digest
, tmp_buf
, 32);
15512 return (PARSER_OK
);
15515 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15517 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15519 u32
*digest
= (u32
*) hash_buf
->digest
;
15521 salt_t
*salt
= hash_buf
->salt
;
15527 char decrypted
[76] = { 0 }; // iv + hash
15529 juniper_decrypt_hash (input_buf
, decrypted
);
15531 char *md5crypt_hash
= decrypted
+ 12;
15533 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15535 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15537 char *salt_pos
= md5crypt_hash
+ 3;
15539 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15541 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15543 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15547 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15549 return (PARSER_OK
);
15552 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15554 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15556 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15558 u32
*digest
= (u32
*) hash_buf
->digest
;
15560 salt_t
*salt
= hash_buf
->salt
;
15562 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15568 // first is *raw* salt
15570 char *salt_pos
= input_buf
+ 3;
15572 char *hash_pos
= strchr (salt_pos
, '$');
15574 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15576 uint salt_len
= hash_pos
- salt_pos
;
15578 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15582 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15584 memcpy (salt_buf_ptr
, salt_pos
, 14);
15586 salt_buf_ptr
[17] = 0x01;
15587 salt_buf_ptr
[18] = 0x80;
15589 // add some stuff to normal salt to make sorted happy
15591 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15592 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15593 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15594 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15596 salt
->salt_len
= salt_len
;
15597 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15599 // base64 decode hash
15601 u8 tmp_buf
[100] = { 0 };
15603 uint hash_len
= input_len
- 3 - salt_len
- 1;
15605 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15607 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15609 memcpy (digest
, tmp_buf
, 32);
15611 digest
[0] = byte_swap_32 (digest
[0]);
15612 digest
[1] = byte_swap_32 (digest
[1]);
15613 digest
[2] = byte_swap_32 (digest
[2]);
15614 digest
[3] = byte_swap_32 (digest
[3]);
15615 digest
[4] = byte_swap_32 (digest
[4]);
15616 digest
[5] = byte_swap_32 (digest
[5]);
15617 digest
[6] = byte_swap_32 (digest
[6]);
15618 digest
[7] = byte_swap_32 (digest
[7]);
15620 return (PARSER_OK
);
15623 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15625 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15627 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15629 u32
*digest
= (u32
*) hash_buf
->digest
;
15631 salt_t
*salt
= hash_buf
->salt
;
15637 // first is *raw* salt
15639 char *salt_pos
= input_buf
+ 3;
15641 char *hash_pos
= strchr (salt_pos
, '$');
15643 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15645 uint salt_len
= hash_pos
- salt_pos
;
15647 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15649 salt
->salt_len
= salt_len
;
15652 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15654 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15655 salt_buf_ptr
[salt_len
] = 0;
15657 // base64 decode hash
15659 u8 tmp_buf
[100] = { 0 };
15661 uint hash_len
= input_len
- 3 - salt_len
- 1;
15663 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15665 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15667 memcpy (digest
, tmp_buf
, 32);
15670 salt
->scrypt_N
= 16384;
15671 salt
->scrypt_r
= 1;
15672 salt
->scrypt_p
= 1;
15673 salt
->salt_iter
= 1;
15675 return (PARSER_OK
);
15678 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15680 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15682 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15684 u32
*digest
= (u32
*) hash_buf
->digest
;
15686 salt_t
*salt
= hash_buf
->salt
;
15688 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15694 char *version_pos
= input_buf
+ 8 + 1;
15696 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15698 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15700 u32 version_len
= verifierHashSize_pos
- version_pos
;
15702 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15704 verifierHashSize_pos
++;
15706 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15708 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15710 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15712 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15716 char *saltSize_pos
= strchr (keySize_pos
, '*');
15718 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15720 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15722 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15726 char *osalt_pos
= strchr (saltSize_pos
, '*');
15728 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15730 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15732 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15736 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15738 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15740 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15742 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15744 encryptedVerifier_pos
++;
15746 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15748 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15750 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15752 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15754 encryptedVerifierHash_pos
++;
15756 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;
15758 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15760 const uint version
= atoi (version_pos
);
15762 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15764 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15766 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15768 const uint keySize
= atoi (keySize_pos
);
15770 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15772 office2007
->keySize
= keySize
;
15774 const uint saltSize
= atoi (saltSize_pos
);
15776 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15782 salt
->salt_len
= 16;
15783 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15785 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15786 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15787 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15788 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15794 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15795 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15796 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15797 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15799 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15800 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15801 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15802 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15803 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15809 digest
[0] = office2007
->encryptedVerifierHash
[0];
15810 digest
[1] = office2007
->encryptedVerifierHash
[1];
15811 digest
[2] = office2007
->encryptedVerifierHash
[2];
15812 digest
[3] = office2007
->encryptedVerifierHash
[3];
15814 return (PARSER_OK
);
15817 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15819 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15821 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15823 u32
*digest
= (u32
*) hash_buf
->digest
;
15825 salt_t
*salt
= hash_buf
->salt
;
15827 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15833 char *version_pos
= input_buf
+ 8 + 1;
15835 char *spinCount_pos
= strchr (version_pos
, '*');
15837 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15839 u32 version_len
= spinCount_pos
- version_pos
;
15841 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15845 char *keySize_pos
= strchr (spinCount_pos
, '*');
15847 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15849 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15851 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15855 char *saltSize_pos
= strchr (keySize_pos
, '*');
15857 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15859 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15861 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15865 char *osalt_pos
= strchr (saltSize_pos
, '*');
15867 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15869 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15871 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15875 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15877 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15879 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15881 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15883 encryptedVerifier_pos
++;
15885 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15887 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15889 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15891 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15893 encryptedVerifierHash_pos
++;
15895 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;
15897 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15899 const uint version
= atoi (version_pos
);
15901 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15903 const uint spinCount
= atoi (spinCount_pos
);
15905 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15907 const uint keySize
= atoi (keySize_pos
);
15909 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15911 const uint saltSize
= atoi (saltSize_pos
);
15913 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15919 salt
->salt_len
= 16;
15920 salt
->salt_iter
= spinCount
;
15922 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15923 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15924 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15925 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15931 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15932 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15933 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15934 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15936 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15937 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15938 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15939 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15940 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15941 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15942 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15943 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15949 digest
[0] = office2010
->encryptedVerifierHash
[0];
15950 digest
[1] = office2010
->encryptedVerifierHash
[1];
15951 digest
[2] = office2010
->encryptedVerifierHash
[2];
15952 digest
[3] = office2010
->encryptedVerifierHash
[3];
15954 return (PARSER_OK
);
15957 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15959 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15961 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15963 u32
*digest
= (u32
*) hash_buf
->digest
;
15965 salt_t
*salt
= hash_buf
->salt
;
15967 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15973 char *version_pos
= input_buf
+ 8 + 1;
15975 char *spinCount_pos
= strchr (version_pos
, '*');
15977 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15979 u32 version_len
= spinCount_pos
- version_pos
;
15981 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15985 char *keySize_pos
= strchr (spinCount_pos
, '*');
15987 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15989 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15991 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15995 char *saltSize_pos
= strchr (keySize_pos
, '*');
15997 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15999 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16001 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16005 char *osalt_pos
= strchr (saltSize_pos
, '*');
16007 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16009 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16011 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16015 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16017 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16019 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16021 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16023 encryptedVerifier_pos
++;
16025 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16027 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16029 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16031 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16033 encryptedVerifierHash_pos
++;
16035 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;
16037 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16039 const uint version
= atoi (version_pos
);
16041 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16043 const uint spinCount
= atoi (spinCount_pos
);
16045 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16047 const uint keySize
= atoi (keySize_pos
);
16049 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16051 const uint saltSize
= atoi (saltSize_pos
);
16053 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16059 salt
->salt_len
= 16;
16060 salt
->salt_iter
= spinCount
;
16062 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16063 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16064 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16065 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16071 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16072 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16073 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16074 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16076 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16077 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16078 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16079 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16080 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16081 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16082 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16083 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16089 digest
[0] = office2013
->encryptedVerifierHash
[0];
16090 digest
[1] = office2013
->encryptedVerifierHash
[1];
16091 digest
[2] = office2013
->encryptedVerifierHash
[2];
16092 digest
[3] = office2013
->encryptedVerifierHash
[3];
16094 return (PARSER_OK
);
16097 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16099 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16101 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16103 u32
*digest
= (u32
*) hash_buf
->digest
;
16105 salt_t
*salt
= hash_buf
->salt
;
16107 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16113 char *version_pos
= input_buf
+ 11;
16115 char *osalt_pos
= strchr (version_pos
, '*');
16117 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16119 u32 version_len
= osalt_pos
- version_pos
;
16121 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16125 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16127 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16129 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16131 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16133 encryptedVerifier_pos
++;
16135 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16137 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16139 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16141 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16143 encryptedVerifierHash_pos
++;
16145 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16147 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16149 const uint version
= *version_pos
- 0x30;
16151 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16157 oldoffice01
->version
= version
;
16159 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16160 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16161 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16162 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16164 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16165 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16166 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16167 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16169 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16170 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16171 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16172 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16174 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16175 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16176 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16177 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16183 salt
->salt_len
= 16;
16185 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16186 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16187 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16188 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16190 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16191 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16192 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16193 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16195 // this is a workaround as office produces multiple documents with the same salt
16197 salt
->salt_len
+= 32;
16199 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16200 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16201 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16202 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16203 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16204 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16205 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16206 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16212 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16213 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16214 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16215 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16217 return (PARSER_OK
);
16220 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16222 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16225 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16227 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16229 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16231 u32
*digest
= (u32
*) hash_buf
->digest
;
16233 salt_t
*salt
= hash_buf
->salt
;
16235 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16241 char *version_pos
= input_buf
+ 11;
16243 char *osalt_pos
= strchr (version_pos
, '*');
16245 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16247 u32 version_len
= osalt_pos
- version_pos
;
16249 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16253 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16255 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16257 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16259 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16261 encryptedVerifier_pos
++;
16263 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16265 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16267 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16269 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16271 encryptedVerifierHash_pos
++;
16273 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16275 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16277 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16279 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16283 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16285 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16287 const uint version
= *version_pos
- 0x30;
16289 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16295 oldoffice01
->version
= version
;
16297 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16298 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16299 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16300 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16302 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16303 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16304 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16305 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16307 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16308 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16309 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16310 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16312 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16313 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16314 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16315 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16317 oldoffice01
->rc4key
[1] = 0;
16318 oldoffice01
->rc4key
[0] = 0;
16320 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16321 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16322 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16323 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16324 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16325 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16326 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16327 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16328 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16329 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16331 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16332 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16338 salt
->salt_len
= 16;
16340 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16341 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16342 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16343 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16345 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16346 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16347 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16348 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16350 // this is a workaround as office produces multiple documents with the same salt
16352 salt
->salt_len
+= 32;
16354 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16355 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16356 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16357 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16358 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16359 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16360 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16361 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16367 digest
[0] = oldoffice01
->rc4key
[0];
16368 digest
[1] = oldoffice01
->rc4key
[1];
16372 return (PARSER_OK
);
16375 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16377 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16379 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16381 u32
*digest
= (u32
*) hash_buf
->digest
;
16383 salt_t
*salt
= hash_buf
->salt
;
16385 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16391 char *version_pos
= input_buf
+ 11;
16393 char *osalt_pos
= strchr (version_pos
, '*');
16395 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16397 u32 version_len
= osalt_pos
- version_pos
;
16399 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16403 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16405 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16407 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16409 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16411 encryptedVerifier_pos
++;
16413 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16415 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16419 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16421 encryptedVerifierHash_pos
++;
16423 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16425 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16427 const uint version
= *version_pos
- 0x30;
16429 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16435 oldoffice34
->version
= version
;
16437 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16438 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16439 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16440 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16442 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16443 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16444 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16445 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16447 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16448 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16449 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16450 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16451 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16453 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16454 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16455 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16456 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16457 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16463 salt
->salt_len
= 16;
16465 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16466 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16467 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16468 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16470 // this is a workaround as office produces multiple documents with the same salt
16472 salt
->salt_len
+= 32;
16474 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16475 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16476 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16477 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16478 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16479 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16480 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16481 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16487 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16488 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16489 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16490 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16492 return (PARSER_OK
);
16495 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16497 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16499 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16502 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16504 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16506 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16508 u32
*digest
= (u32
*) hash_buf
->digest
;
16510 salt_t
*salt
= hash_buf
->salt
;
16512 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16518 char *version_pos
= input_buf
+ 11;
16520 char *osalt_pos
= strchr (version_pos
, '*');
16522 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16524 u32 version_len
= osalt_pos
- version_pos
;
16526 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16530 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16532 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16534 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16536 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16538 encryptedVerifier_pos
++;
16540 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16542 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16544 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16546 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16548 encryptedVerifierHash_pos
++;
16550 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16552 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16554 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16556 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16560 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16562 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16564 const uint version
= *version_pos
- 0x30;
16566 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16572 oldoffice34
->version
= version
;
16574 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16575 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16576 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16577 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16579 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16580 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16581 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16582 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16584 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16585 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16586 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16587 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16588 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16590 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16591 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16592 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16593 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16594 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16596 oldoffice34
->rc4key
[1] = 0;
16597 oldoffice34
->rc4key
[0] = 0;
16599 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16600 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16601 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16602 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16603 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16604 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16605 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16606 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16607 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16608 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16610 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16611 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16617 salt
->salt_len
= 16;
16619 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16620 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16621 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16622 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16624 // this is a workaround as office produces multiple documents with the same salt
16626 salt
->salt_len
+= 32;
16628 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16629 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16630 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16631 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16632 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16633 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16634 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16635 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16641 digest
[0] = oldoffice34
->rc4key
[0];
16642 digest
[1] = oldoffice34
->rc4key
[1];
16646 return (PARSER_OK
);
16649 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16651 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16653 u32
*digest
= (u32
*) hash_buf
->digest
;
16655 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16656 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16657 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16658 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16660 digest
[0] = byte_swap_32 (digest
[0]);
16661 digest
[1] = byte_swap_32 (digest
[1]);
16662 digest
[2] = byte_swap_32 (digest
[2]);
16663 digest
[3] = byte_swap_32 (digest
[3]);
16665 return (PARSER_OK
);
16668 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16670 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16672 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16674 u32
*digest
= (u32
*) hash_buf
->digest
;
16676 salt_t
*salt
= hash_buf
->salt
;
16678 char *signature_pos
= input_buf
;
16680 char *salt_pos
= strchr (signature_pos
, '$');
16682 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16684 u32 signature_len
= salt_pos
- signature_pos
;
16686 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16690 char *hash_pos
= strchr (salt_pos
, '$');
16692 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16694 u32 salt_len
= hash_pos
- salt_pos
;
16696 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16700 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16702 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16704 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16705 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16706 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16707 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16708 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16710 digest
[0] -= SHA1M_A
;
16711 digest
[1] -= SHA1M_B
;
16712 digest
[2] -= SHA1M_C
;
16713 digest
[3] -= SHA1M_D
;
16714 digest
[4] -= SHA1M_E
;
16716 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16718 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16720 salt
->salt_len
= salt_len
;
16722 return (PARSER_OK
);
16725 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16727 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16729 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16731 u32
*digest
= (u32
*) hash_buf
->digest
;
16733 salt_t
*salt
= hash_buf
->salt
;
16735 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16741 char *iter_pos
= input_buf
+ 14;
16743 const int iter
= atoi (iter_pos
);
16745 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16747 salt
->salt_iter
= iter
- 1;
16749 char *salt_pos
= strchr (iter_pos
, '$');
16751 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16755 char *hash_pos
= strchr (salt_pos
, '$');
16757 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16759 const uint salt_len
= hash_pos
- salt_pos
;
16763 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16765 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16767 salt
->salt_len
= salt_len
;
16769 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16770 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16772 // add some stuff to normal salt to make sorted happy
16774 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16775 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16776 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16777 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16778 salt
->salt_buf
[4] = salt
->salt_iter
;
16780 // base64 decode hash
16782 u8 tmp_buf
[100] = { 0 };
16784 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16786 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16788 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16790 memcpy (digest
, tmp_buf
, 32);
16792 digest
[0] = byte_swap_32 (digest
[0]);
16793 digest
[1] = byte_swap_32 (digest
[1]);
16794 digest
[2] = byte_swap_32 (digest
[2]);
16795 digest
[3] = byte_swap_32 (digest
[3]);
16796 digest
[4] = byte_swap_32 (digest
[4]);
16797 digest
[5] = byte_swap_32 (digest
[5]);
16798 digest
[6] = byte_swap_32 (digest
[6]);
16799 digest
[7] = byte_swap_32 (digest
[7]);
16801 return (PARSER_OK
);
16804 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16806 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16808 u32
*digest
= (u32
*) hash_buf
->digest
;
16810 salt_t
*salt
= hash_buf
->salt
;
16812 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16813 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16817 digest
[0] = byte_swap_32 (digest
[0]);
16818 digest
[1] = byte_swap_32 (digest
[1]);
16820 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16821 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16822 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16824 char iter_c
= input_buf
[17];
16825 char iter_d
= input_buf
[19];
16827 // atm only defaults, let's see if there's more request
16828 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16829 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16831 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16833 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16834 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16835 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16836 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16838 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16839 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16840 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16841 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16843 salt
->salt_len
= 16;
16845 return (PARSER_OK
);
16848 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16850 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16852 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16854 u32
*digest
= (u32
*) hash_buf
->digest
;
16856 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16858 salt_t
*salt
= hash_buf
->salt
;
16860 char *salt_pos
= input_buf
+ 10;
16862 char *hash_pos
= strchr (salt_pos
, '$');
16864 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 uint salt_len
= hash_pos
- salt_pos
;
16870 uint hash_len
= input_len
- 10 - salt_len
- 1;
16872 // base64 decode salt
16874 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16876 u8 tmp_buf
[100] = { 0 };
16878 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16880 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16882 tmp_buf
[salt_len
] = 0x80;
16884 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16886 salt
->salt_len
= salt_len
;
16888 // base64 decode hash
16890 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16892 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16894 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16896 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16898 uint user_len
= hash_len
- 32;
16900 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16902 user_len
--; // skip the trailing space
16904 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16905 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16906 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16907 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16909 digest
[0] = byte_swap_32 (digest
[0]);
16910 digest
[1] = byte_swap_32 (digest
[1]);
16911 digest
[2] = byte_swap_32 (digest
[2]);
16912 digest
[3] = byte_swap_32 (digest
[3]);
16914 // store username for host only (output hash if cracked)
16916 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16917 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16919 return (PARSER_OK
);
16922 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16924 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16926 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16928 u32
*digest
= (u32
*) hash_buf
->digest
;
16930 salt_t
*salt
= hash_buf
->salt
;
16932 char *iter_pos
= input_buf
+ 10;
16934 u32 iter
= atoi (iter_pos
);
16938 return (PARSER_SALT_ITERATION
);
16941 iter
--; // first iteration is special
16943 salt
->salt_iter
= iter
;
16945 char *base64_pos
= strchr (iter_pos
, '}');
16947 if (base64_pos
== NULL
)
16949 return (PARSER_SIGNATURE_UNMATCHED
);
16954 // base64 decode salt
16956 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16958 u8 tmp_buf
[100] = { 0 };
16960 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16962 if (decoded_len
< 24)
16964 return (PARSER_SALT_LENGTH
);
16969 uint salt_len
= decoded_len
- 20;
16971 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16972 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16974 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16976 salt
->salt_len
= salt_len
;
16980 u32
*digest_ptr
= (u32
*) tmp_buf
;
16982 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16983 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16984 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16985 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16986 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16988 return (PARSER_OK
);
16991 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16993 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16995 u32
*digest
= (u32
*) hash_buf
->digest
;
16997 salt_t
*salt
= hash_buf
->salt
;
16999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17003 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17005 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17007 uint salt_len
= input_len
- 40 - 1;
17009 char *salt_buf
= input_buf
+ 40 + 1;
17011 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17013 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17015 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17017 salt
->salt_len
= salt_len
;
17019 return (PARSER_OK
);
17022 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17024 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17026 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17028 u32
*digest
= (u32
*) hash_buf
->digest
;
17030 salt_t
*salt
= hash_buf
->salt
;
17032 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17038 char *V_pos
= input_buf
+ 5;
17040 char *R_pos
= strchr (V_pos
, '*');
17042 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17044 u32 V_len
= R_pos
- V_pos
;
17048 char *bits_pos
= strchr (R_pos
, '*');
17050 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 u32 R_len
= bits_pos
- R_pos
;
17056 char *P_pos
= strchr (bits_pos
, '*');
17058 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17060 u32 bits_len
= P_pos
- bits_pos
;
17064 char *enc_md_pos
= strchr (P_pos
, '*');
17066 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17068 u32 P_len
= enc_md_pos
- P_pos
;
17072 char *id_len_pos
= strchr (enc_md_pos
, '*');
17074 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17076 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17080 char *id_buf_pos
= strchr (id_len_pos
, '*');
17082 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17084 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17088 char *u_len_pos
= strchr (id_buf_pos
, '*');
17090 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17092 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17094 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17098 char *u_buf_pos
= strchr (u_len_pos
, '*');
17100 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17102 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17106 char *o_len_pos
= strchr (u_buf_pos
, '*');
17108 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17110 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17112 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17116 char *o_buf_pos
= strchr (o_len_pos
, '*');
17118 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17120 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17124 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;
17126 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17130 const int V
= atoi (V_pos
);
17131 const int R
= atoi (R_pos
);
17132 const int P
= atoi (P_pos
);
17134 if (V
!= 1) return (PARSER_SALT_VALUE
);
17135 if (R
!= 2) return (PARSER_SALT_VALUE
);
17137 const int enc_md
= atoi (enc_md_pos
);
17139 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17141 const int id_len
= atoi (id_len_pos
);
17142 const int u_len
= atoi (u_len_pos
);
17143 const int o_len
= atoi (o_len_pos
);
17145 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17146 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17147 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17149 const int bits
= atoi (bits_pos
);
17151 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17153 // copy data to esalt
17159 pdf
->enc_md
= enc_md
;
17161 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17162 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17163 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17164 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17165 pdf
->id_len
= id_len
;
17167 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17168 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17169 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17170 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17171 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17172 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17173 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17174 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17175 pdf
->u_len
= u_len
;
17177 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17178 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17179 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17180 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17181 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17182 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17183 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17184 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17185 pdf
->o_len
= o_len
;
17187 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17188 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17189 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17190 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17192 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17193 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17194 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17195 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17196 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17197 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17198 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17199 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17201 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17202 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17203 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17204 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17205 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17206 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17207 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17208 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17210 // we use ID for salt, maybe needs to change, we will see...
17212 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17213 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17214 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17215 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17216 salt
->salt_len
= pdf
->id_len
;
17218 digest
[0] = pdf
->u_buf
[0];
17219 digest
[1] = pdf
->u_buf
[1];
17220 digest
[2] = pdf
->u_buf
[2];
17221 digest
[3] = pdf
->u_buf
[3];
17223 return (PARSER_OK
);
17226 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17228 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17231 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17233 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17235 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17237 u32
*digest
= (u32
*) hash_buf
->digest
;
17239 salt_t
*salt
= hash_buf
->salt
;
17241 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17247 char *V_pos
= input_buf
+ 5;
17249 char *R_pos
= strchr (V_pos
, '*');
17251 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 V_len
= R_pos
- V_pos
;
17257 char *bits_pos
= strchr (R_pos
, '*');
17259 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 R_len
= bits_pos
- R_pos
;
17265 char *P_pos
= strchr (bits_pos
, '*');
17267 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 u32 bits_len
= P_pos
- bits_pos
;
17273 char *enc_md_pos
= strchr (P_pos
, '*');
17275 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17277 u32 P_len
= enc_md_pos
- P_pos
;
17281 char *id_len_pos
= strchr (enc_md_pos
, '*');
17283 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17285 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17289 char *id_buf_pos
= strchr (id_len_pos
, '*');
17291 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17293 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17297 char *u_len_pos
= strchr (id_buf_pos
, '*');
17299 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17301 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17303 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17307 char *u_buf_pos
= strchr (u_len_pos
, '*');
17309 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17315 char *o_len_pos
= strchr (u_buf_pos
, '*');
17317 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17319 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17321 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17325 char *o_buf_pos
= strchr (o_len_pos
, '*');
17327 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17329 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17333 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17335 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17337 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17339 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17343 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;
17345 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17349 const int V
= atoi (V_pos
);
17350 const int R
= atoi (R_pos
);
17351 const int P
= atoi (P_pos
);
17353 if (V
!= 1) return (PARSER_SALT_VALUE
);
17354 if (R
!= 2) return (PARSER_SALT_VALUE
);
17356 const int enc_md
= atoi (enc_md_pos
);
17358 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17360 const int id_len
= atoi (id_len_pos
);
17361 const int u_len
= atoi (u_len_pos
);
17362 const int o_len
= atoi (o_len_pos
);
17364 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17365 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17366 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17368 const int bits
= atoi (bits_pos
);
17370 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17372 // copy data to esalt
17378 pdf
->enc_md
= enc_md
;
17380 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17381 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17382 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17383 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17384 pdf
->id_len
= id_len
;
17386 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17387 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17388 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17389 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17390 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17391 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17392 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17393 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17394 pdf
->u_len
= u_len
;
17396 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17397 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17398 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17399 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17400 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17401 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17402 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17403 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17404 pdf
->o_len
= o_len
;
17406 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17407 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17408 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17409 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17411 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17412 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17413 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17414 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17415 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17416 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17417 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17418 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17420 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17421 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17422 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17423 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17424 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17425 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17426 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17427 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17429 pdf
->rc4key
[1] = 0;
17430 pdf
->rc4key
[0] = 0;
17432 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17433 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17434 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17435 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17436 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17437 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17438 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17439 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17440 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17441 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17443 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17444 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17446 // we use ID for salt, maybe needs to change, we will see...
17448 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17449 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17450 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17451 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17452 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17453 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17454 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17455 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17456 salt
->salt_len
= pdf
->id_len
+ 16;
17458 digest
[0] = pdf
->rc4key
[0];
17459 digest
[1] = pdf
->rc4key
[1];
17463 return (PARSER_OK
);
17466 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17468 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17470 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17472 u32
*digest
= (u32
*) hash_buf
->digest
;
17474 salt_t
*salt
= hash_buf
->salt
;
17476 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17482 char *V_pos
= input_buf
+ 5;
17484 char *R_pos
= strchr (V_pos
, '*');
17486 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17488 u32 V_len
= R_pos
- V_pos
;
17492 char *bits_pos
= strchr (R_pos
, '*');
17494 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17496 u32 R_len
= bits_pos
- R_pos
;
17500 char *P_pos
= strchr (bits_pos
, '*');
17502 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17504 u32 bits_len
= P_pos
- bits_pos
;
17508 char *enc_md_pos
= strchr (P_pos
, '*');
17510 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17512 u32 P_len
= enc_md_pos
- P_pos
;
17516 char *id_len_pos
= strchr (enc_md_pos
, '*');
17518 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17520 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17524 char *id_buf_pos
= strchr (id_len_pos
, '*');
17526 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17528 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17532 char *u_len_pos
= strchr (id_buf_pos
, '*');
17534 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17536 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17538 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17542 char *u_buf_pos
= strchr (u_len_pos
, '*');
17544 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17546 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17550 char *o_len_pos
= strchr (u_buf_pos
, '*');
17552 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17554 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17556 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17560 char *o_buf_pos
= strchr (o_len_pos
, '*');
17562 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17564 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17568 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;
17570 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17574 const int V
= atoi (V_pos
);
17575 const int R
= atoi (R_pos
);
17576 const int P
= atoi (P_pos
);
17580 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17581 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17583 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17585 const int id_len
= atoi (id_len_pos
);
17586 const int u_len
= atoi (u_len_pos
);
17587 const int o_len
= atoi (o_len_pos
);
17589 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17591 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17592 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17594 const int bits
= atoi (bits_pos
);
17596 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17602 enc_md
= atoi (enc_md_pos
);
17605 // copy data to esalt
17611 pdf
->enc_md
= enc_md
;
17613 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17614 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17615 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17616 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17620 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17621 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17622 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17623 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17626 pdf
->id_len
= id_len
;
17628 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17629 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17630 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17631 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17632 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17633 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17634 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17635 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17636 pdf
->u_len
= u_len
;
17638 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17639 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17640 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17641 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17642 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17643 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17644 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17645 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17646 pdf
->o_len
= o_len
;
17648 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17649 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17650 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17651 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17655 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17656 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17657 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17658 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17661 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17662 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17663 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17664 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17665 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17666 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17667 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17668 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17670 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17671 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17672 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17673 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17674 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17675 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17676 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17677 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17679 // precompute rc4 data for later use
17695 uint salt_pc_block
[32] = { 0 };
17697 char *salt_pc_ptr
= (char *) salt_pc_block
;
17699 memcpy (salt_pc_ptr
, padding
, 32);
17700 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17702 uint salt_pc_digest
[4] = { 0 };
17704 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17706 pdf
->rc4data
[0] = salt_pc_digest
[0];
17707 pdf
->rc4data
[1] = salt_pc_digest
[1];
17709 // we use ID for salt, maybe needs to change, we will see...
17711 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17712 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17713 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17714 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17715 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17716 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17717 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17718 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17719 salt
->salt_len
= pdf
->id_len
+ 16;
17721 salt
->salt_iter
= ROUNDS_PDF14
;
17723 digest
[0] = pdf
->u_buf
[0];
17724 digest
[1] = pdf
->u_buf
[1];
17728 return (PARSER_OK
);
17731 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17733 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17735 if (ret
!= PARSER_OK
)
17740 u32
*digest
= (u32
*) hash_buf
->digest
;
17742 salt_t
*salt
= hash_buf
->salt
;
17744 digest
[0] -= SHA256M_A
;
17745 digest
[1] -= SHA256M_B
;
17746 digest
[2] -= SHA256M_C
;
17747 digest
[3] -= SHA256M_D
;
17748 digest
[4] -= SHA256M_E
;
17749 digest
[5] -= SHA256M_F
;
17750 digest
[6] -= SHA256M_G
;
17751 digest
[7] -= SHA256M_H
;
17753 salt
->salt_buf
[2] = 0x80;
17755 return (PARSER_OK
);
17758 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17760 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17762 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17764 u32
*digest
= (u32
*) hash_buf
->digest
;
17766 salt_t
*salt
= hash_buf
->salt
;
17768 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17774 char *V_pos
= input_buf
+ 5;
17776 char *R_pos
= strchr (V_pos
, '*');
17778 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17780 u32 V_len
= R_pos
- V_pos
;
17784 char *bits_pos
= strchr (R_pos
, '*');
17786 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17788 u32 R_len
= bits_pos
- R_pos
;
17792 char *P_pos
= strchr (bits_pos
, '*');
17794 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17796 u32 bits_len
= P_pos
- bits_pos
;
17800 char *enc_md_pos
= strchr (P_pos
, '*');
17802 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17804 u32 P_len
= enc_md_pos
- P_pos
;
17808 char *id_len_pos
= strchr (enc_md_pos
, '*');
17810 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17812 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17816 char *id_buf_pos
= strchr (id_len_pos
, '*');
17818 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17820 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17824 char *u_len_pos
= strchr (id_buf_pos
, '*');
17826 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17828 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17832 char *u_buf_pos
= strchr (u_len_pos
, '*');
17834 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17836 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17840 char *o_len_pos
= strchr (u_buf_pos
, '*');
17842 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17844 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17848 char *o_buf_pos
= strchr (o_len_pos
, '*');
17850 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17852 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17856 char *last
= strchr (o_buf_pos
, '*');
17858 if (last
== NULL
) last
= input_buf
+ input_len
;
17860 u32 o_buf_len
= last
- o_buf_pos
;
17864 const int V
= atoi (V_pos
);
17865 const int R
= atoi (R_pos
);
17869 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17870 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17872 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17874 const int bits
= atoi (bits_pos
);
17876 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17878 int enc_md
= atoi (enc_md_pos
);
17880 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17882 const uint id_len
= atoi (id_len_pos
);
17883 const uint u_len
= atoi (u_len_pos
);
17884 const uint o_len
= atoi (o_len_pos
);
17886 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17887 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17888 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17889 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17890 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17891 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17892 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17893 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17895 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17896 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17897 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17899 // copy data to esalt
17901 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17903 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17905 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17908 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17909 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17911 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17912 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17914 salt
->salt_len
= 8;
17915 salt
->salt_iter
= ROUNDS_PDF17L8
;
17917 digest
[0] = pdf
->u_buf
[0];
17918 digest
[1] = pdf
->u_buf
[1];
17919 digest
[2] = pdf
->u_buf
[2];
17920 digest
[3] = pdf
->u_buf
[3];
17921 digest
[4] = pdf
->u_buf
[4];
17922 digest
[5] = pdf
->u_buf
[5];
17923 digest
[6] = pdf
->u_buf
[6];
17924 digest
[7] = pdf
->u_buf
[7];
17926 return (PARSER_OK
);
17929 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17931 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17933 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17935 u32
*digest
= (u32
*) hash_buf
->digest
;
17937 salt_t
*salt
= hash_buf
->salt
;
17939 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17947 char *iter_pos
= input_buf
+ 7;
17949 u32 iter
= atoi (iter_pos
);
17951 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17952 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17954 // first is *raw* salt
17956 char *salt_pos
= strchr (iter_pos
, ':');
17958 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17962 char *hash_pos
= strchr (salt_pos
, ':');
17964 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17966 u32 salt_len
= hash_pos
- salt_pos
;
17968 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17972 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17974 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17978 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17980 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17982 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17984 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17985 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17987 salt
->salt_len
= salt_len
;
17988 salt
->salt_iter
= iter
- 1;
17992 u8 tmp_buf
[100] = { 0 };
17994 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17996 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17998 memcpy (digest
, tmp_buf
, 16);
18000 digest
[0] = byte_swap_32 (digest
[0]);
18001 digest
[1] = byte_swap_32 (digest
[1]);
18002 digest
[2] = byte_swap_32 (digest
[2]);
18003 digest
[3] = byte_swap_32 (digest
[3]);
18005 // add some stuff to normal salt to make sorted happy
18007 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18008 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18009 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18010 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18011 salt
->salt_buf
[4] = salt
->salt_iter
;
18013 return (PARSER_OK
);
18016 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18018 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18020 u32
*digest
= (u32
*) hash_buf
->digest
;
18022 salt_t
*salt
= hash_buf
->salt
;
18024 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18025 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18026 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18027 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18029 digest
[0] = byte_swap_32 (digest
[0]);
18030 digest
[1] = byte_swap_32 (digest
[1]);
18031 digest
[2] = byte_swap_32 (digest
[2]);
18032 digest
[3] = byte_swap_32 (digest
[3]);
18034 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18036 uint salt_len
= input_len
- 32 - 1;
18038 char *salt_buf
= input_buf
+ 32 + 1;
18040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18042 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18044 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18046 salt
->salt_len
= salt_len
;
18048 return (PARSER_OK
);
18051 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18053 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18055 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18057 u32
*digest
= (u32
*) hash_buf
->digest
;
18059 salt_t
*salt
= hash_buf
->salt
;
18061 char *user_pos
= input_buf
+ 10;
18063 char *salt_pos
= strchr (user_pos
, '*');
18065 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18069 char *hash_pos
= strchr (salt_pos
, '*');
18073 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18075 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18077 uint user_len
= salt_pos
- user_pos
- 1;
18079 uint salt_len
= hash_pos
- salt_pos
- 1;
18081 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18087 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18088 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18089 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18090 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18092 digest
[0] = byte_swap_32 (digest
[0]);
18093 digest
[1] = byte_swap_32 (digest
[1]);
18094 digest
[2] = byte_swap_32 (digest
[2]);
18095 digest
[3] = byte_swap_32 (digest
[3]);
18097 digest
[0] -= MD5M_A
;
18098 digest
[1] -= MD5M_B
;
18099 digest
[2] -= MD5M_C
;
18100 digest
[3] -= MD5M_D
;
18106 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18108 // first 4 bytes are the "challenge"
18110 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18111 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18112 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18113 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18115 // append the user name
18117 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18119 salt
->salt_len
= 4 + user_len
;
18121 return (PARSER_OK
);
18124 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18126 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18128 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18130 u32
*digest
= (u32
*) hash_buf
->digest
;
18132 salt_t
*salt
= hash_buf
->salt
;
18134 char *salt_pos
= input_buf
+ 9;
18136 char *hash_pos
= strchr (salt_pos
, '*');
18138 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18142 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18144 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18146 uint salt_len
= hash_pos
- salt_pos
- 1;
18148 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18154 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18155 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18156 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18157 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18158 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18164 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18166 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18168 salt
->salt_len
= salt_len
;
18170 return (PARSER_OK
);
18173 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18175 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18177 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18179 u32
*digest
= (u32
*) hash_buf
->digest
;
18181 salt_t
*salt
= hash_buf
->salt
;
18183 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18189 char *cry_master_len_pos
= input_buf
+ 9;
18191 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18193 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18197 cry_master_buf_pos
++;
18199 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18201 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18203 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18205 cry_salt_len_pos
++;
18207 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18209 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18211 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18213 cry_salt_buf_pos
++;
18215 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18217 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18219 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18223 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18225 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18227 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18231 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18233 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18235 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18239 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18241 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18243 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18245 public_key_len_pos
++;
18247 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18249 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18251 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18253 public_key_buf_pos
++;
18255 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;
18257 const uint cry_master_len
= atoi (cry_master_len_pos
);
18258 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18259 const uint ckey_len
= atoi (ckey_len_pos
);
18260 const uint public_key_len
= atoi (public_key_len_pos
);
18262 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18263 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18264 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18265 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18267 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18269 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18271 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18274 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18276 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18278 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18281 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18283 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18285 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18288 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18289 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18290 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18293 * store digest (should be unique enought, hopefully)
18296 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18297 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18298 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18299 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18305 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18307 const uint cry_rounds
= atoi (cry_rounds_pos
);
18309 salt
->salt_iter
= cry_rounds
- 1;
18311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18313 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18315 salt
->salt_len
= salt_len
;
18317 return (PARSER_OK
);
18320 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18322 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18324 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18326 u32
*digest
= (u32
*) hash_buf
->digest
;
18328 salt_t
*salt
= hash_buf
->salt
;
18330 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18332 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18334 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18336 memcpy (temp_input_buf
, input_buf
, input_len
);
18340 char *URI_server_pos
= temp_input_buf
+ 6;
18342 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18344 if (URI_client_pos
== NULL
)
18346 myfree (temp_input_buf
);
18348 return (PARSER_SEPARATOR_UNMATCHED
);
18351 URI_client_pos
[0] = 0;
18354 uint URI_server_len
= strlen (URI_server_pos
);
18356 if (URI_server_len
> 512)
18358 myfree (temp_input_buf
);
18360 return (PARSER_SALT_LENGTH
);
18365 char *user_pos
= strchr (URI_client_pos
, '*');
18367 if (user_pos
== NULL
)
18369 myfree (temp_input_buf
);
18371 return (PARSER_SEPARATOR_UNMATCHED
);
18377 uint URI_client_len
= strlen (URI_client_pos
);
18379 if (URI_client_len
> 512)
18381 myfree (temp_input_buf
);
18383 return (PARSER_SALT_LENGTH
);
18388 char *realm_pos
= strchr (user_pos
, '*');
18390 if (realm_pos
== NULL
)
18392 myfree (temp_input_buf
);
18394 return (PARSER_SEPARATOR_UNMATCHED
);
18400 uint user_len
= strlen (user_pos
);
18402 if (user_len
> 116)
18404 myfree (temp_input_buf
);
18406 return (PARSER_SALT_LENGTH
);
18411 char *method_pos
= strchr (realm_pos
, '*');
18413 if (method_pos
== NULL
)
18415 myfree (temp_input_buf
);
18417 return (PARSER_SEPARATOR_UNMATCHED
);
18423 uint realm_len
= strlen (realm_pos
);
18425 if (realm_len
> 116)
18427 myfree (temp_input_buf
);
18429 return (PARSER_SALT_LENGTH
);
18434 char *URI_prefix_pos
= strchr (method_pos
, '*');
18436 if (URI_prefix_pos
== NULL
)
18438 myfree (temp_input_buf
);
18440 return (PARSER_SEPARATOR_UNMATCHED
);
18443 URI_prefix_pos
[0] = 0;
18446 uint method_len
= strlen (method_pos
);
18448 if (method_len
> 246)
18450 myfree (temp_input_buf
);
18452 return (PARSER_SALT_LENGTH
);
18457 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18459 if (URI_resource_pos
== NULL
)
18461 myfree (temp_input_buf
);
18463 return (PARSER_SEPARATOR_UNMATCHED
);
18466 URI_resource_pos
[0] = 0;
18467 URI_resource_pos
++;
18469 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18471 if (URI_prefix_len
> 245)
18473 myfree (temp_input_buf
);
18475 return (PARSER_SALT_LENGTH
);
18480 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18482 if (URI_suffix_pos
== NULL
)
18484 myfree (temp_input_buf
);
18486 return (PARSER_SEPARATOR_UNMATCHED
);
18489 URI_suffix_pos
[0] = 0;
18492 uint URI_resource_len
= strlen (URI_resource_pos
);
18494 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18496 myfree (temp_input_buf
);
18498 return (PARSER_SALT_LENGTH
);
18503 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18505 if (nonce_pos
== NULL
)
18507 myfree (temp_input_buf
);
18509 return (PARSER_SEPARATOR_UNMATCHED
);
18515 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18517 if (URI_suffix_len
> 245)
18519 myfree (temp_input_buf
);
18521 return (PARSER_SALT_LENGTH
);
18526 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18528 if (nonce_client_pos
== NULL
)
18530 myfree (temp_input_buf
);
18532 return (PARSER_SEPARATOR_UNMATCHED
);
18535 nonce_client_pos
[0] = 0;
18536 nonce_client_pos
++;
18538 uint nonce_len
= strlen (nonce_pos
);
18540 if (nonce_len
< 1 || nonce_len
> 50)
18542 myfree (temp_input_buf
);
18544 return (PARSER_SALT_LENGTH
);
18549 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18551 if (nonce_count_pos
== NULL
)
18553 myfree (temp_input_buf
);
18555 return (PARSER_SEPARATOR_UNMATCHED
);
18558 nonce_count_pos
[0] = 0;
18561 uint nonce_client_len
= strlen (nonce_client_pos
);
18563 if (nonce_client_len
> 50)
18565 myfree (temp_input_buf
);
18567 return (PARSER_SALT_LENGTH
);
18572 char *qop_pos
= strchr (nonce_count_pos
, '*');
18574 if (qop_pos
== NULL
)
18576 myfree (temp_input_buf
);
18578 return (PARSER_SEPARATOR_UNMATCHED
);
18584 uint nonce_count_len
= strlen (nonce_count_pos
);
18586 if (nonce_count_len
> 50)
18588 myfree (temp_input_buf
);
18590 return (PARSER_SALT_LENGTH
);
18595 char *directive_pos
= strchr (qop_pos
, '*');
18597 if (directive_pos
== NULL
)
18599 myfree (temp_input_buf
);
18601 return (PARSER_SEPARATOR_UNMATCHED
);
18604 directive_pos
[0] = 0;
18607 uint qop_len
= strlen (qop_pos
);
18611 myfree (temp_input_buf
);
18613 return (PARSER_SALT_LENGTH
);
18618 char *digest_pos
= strchr (directive_pos
, '*');
18620 if (digest_pos
== NULL
)
18622 myfree (temp_input_buf
);
18624 return (PARSER_SEPARATOR_UNMATCHED
);
18630 uint directive_len
= strlen (directive_pos
);
18632 if (directive_len
!= 3)
18634 myfree (temp_input_buf
);
18636 return (PARSER_SALT_LENGTH
);
18639 if (memcmp (directive_pos
, "MD5", 3))
18641 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18643 myfree (temp_input_buf
);
18645 return (PARSER_SIP_AUTH_DIRECTIVE
);
18649 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18654 uint md5_max_len
= 4 * 64;
18656 uint md5_remaining_len
= md5_max_len
;
18658 uint tmp_md5_buf
[64] = { 0 };
18660 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18662 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18664 md5_len
+= method_len
+ 1;
18665 tmp_md5_ptr
+= method_len
+ 1;
18667 if (URI_prefix_len
> 0)
18669 md5_remaining_len
= md5_max_len
- md5_len
;
18671 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18673 md5_len
+= URI_prefix_len
+ 1;
18674 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18677 md5_remaining_len
= md5_max_len
- md5_len
;
18679 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18681 md5_len
+= URI_resource_len
;
18682 tmp_md5_ptr
+= URI_resource_len
;
18684 if (URI_suffix_len
> 0)
18686 md5_remaining_len
= md5_max_len
- md5_len
;
18688 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18690 md5_len
+= 1 + URI_suffix_len
;
18693 uint tmp_digest
[4] = { 0 };
18695 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18697 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18698 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18699 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18700 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18706 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18708 uint esalt_len
= 0;
18710 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18712 // there are 2 possibilities for the esalt:
18714 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18716 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18718 if (esalt_len
> max_esalt_len
)
18720 myfree (temp_input_buf
);
18722 return (PARSER_SALT_LENGTH
);
18725 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18737 esalt_len
= 1 + nonce_len
+ 1 + 32;
18739 if (esalt_len
> max_esalt_len
)
18741 myfree (temp_input_buf
);
18743 return (PARSER_SALT_LENGTH
);
18746 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18754 // add 0x80 to esalt
18756 esalt_buf_ptr
[esalt_len
] = 0x80;
18758 sip
->esalt_len
= esalt_len
;
18764 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18766 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18768 uint max_salt_len
= 119;
18770 if (salt_len
> max_salt_len
)
18772 myfree (temp_input_buf
);
18774 return (PARSER_SALT_LENGTH
);
18777 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18779 sip
->salt_len
= salt_len
;
18782 * fake salt (for sorting)
18785 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18789 uint fake_salt_len
= salt_len
;
18791 if (fake_salt_len
> max_salt_len
)
18793 fake_salt_len
= max_salt_len
;
18796 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18798 salt
->salt_len
= fake_salt_len
;
18804 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18805 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18806 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18807 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18809 digest
[0] = byte_swap_32 (digest
[0]);
18810 digest
[1] = byte_swap_32 (digest
[1]);
18811 digest
[2] = byte_swap_32 (digest
[2]);
18812 digest
[3] = byte_swap_32 (digest
[3]);
18814 myfree (temp_input_buf
);
18816 return (PARSER_OK
);
18819 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18821 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18823 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18825 u32
*digest
= (u32
*) hash_buf
->digest
;
18827 salt_t
*salt
= hash_buf
->salt
;
18831 char *digest_pos
= input_buf
;
18833 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18840 char *salt_buf
= input_buf
+ 8 + 1;
18844 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18846 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18848 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18850 salt
->salt_len
= salt_len
;
18852 return (PARSER_OK
);
18855 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18857 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18859 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18861 u32
*digest
= (u32
*) hash_buf
->digest
;
18863 salt_t
*salt
= hash_buf
->salt
;
18865 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18871 char *p_buf_pos
= input_buf
+ 4;
18873 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18875 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18877 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18879 NumCyclesPower_pos
++;
18881 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18883 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18885 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18889 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18891 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18893 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18897 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18899 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18901 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18905 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18907 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18909 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18913 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18915 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18917 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18921 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18923 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18925 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18929 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18931 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18933 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18937 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18939 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18941 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18945 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;
18947 const uint iter
= atoi (NumCyclesPower_pos
);
18948 const uint crc
= atoi (crc_buf_pos
);
18949 const uint p_buf
= atoi (p_buf_pos
);
18950 const uint salt_len
= atoi (salt_len_pos
);
18951 const uint iv_len
= atoi (iv_len_pos
);
18952 const uint unpack_size
= atoi (unpack_size_pos
);
18953 const uint data_len
= atoi (data_len_pos
);
18959 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18960 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18962 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18964 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18966 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18972 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18973 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18974 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18975 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18977 seven_zip
->iv_len
= iv_len
;
18979 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18981 seven_zip
->salt_len
= 0;
18983 seven_zip
->crc
= crc
;
18985 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18987 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18989 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18992 seven_zip
->data_len
= data_len
;
18994 seven_zip
->unpack_size
= unpack_size
;
18998 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18999 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19000 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19001 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19003 salt
->salt_len
= 16;
19005 salt
->salt_sign
[0] = iter
;
19007 salt
->salt_iter
= 1 << iter
;
19018 return (PARSER_OK
);
19021 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19023 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19025 u32
*digest
= (u32
*) hash_buf
->digest
;
19027 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19028 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19029 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19030 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19031 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19032 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19033 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19034 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19036 digest
[0] = byte_swap_32 (digest
[0]);
19037 digest
[1] = byte_swap_32 (digest
[1]);
19038 digest
[2] = byte_swap_32 (digest
[2]);
19039 digest
[3] = byte_swap_32 (digest
[3]);
19040 digest
[4] = byte_swap_32 (digest
[4]);
19041 digest
[5] = byte_swap_32 (digest
[5]);
19042 digest
[6] = byte_swap_32 (digest
[6]);
19043 digest
[7] = byte_swap_32 (digest
[7]);
19045 return (PARSER_OK
);
19048 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19050 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19052 u32
*digest
= (u32
*) hash_buf
->digest
;
19054 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19055 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19056 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19057 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19058 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19059 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19060 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19061 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19062 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19063 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19064 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19065 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19066 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19067 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19068 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19069 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19071 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19072 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19073 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19074 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19075 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19076 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19077 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19078 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19079 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19080 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19081 digest
[10] = byte_swap_32 (digest
[10]);
19082 digest
[11] = byte_swap_32 (digest
[11]);
19083 digest
[12] = byte_swap_32 (digest
[12]);
19084 digest
[13] = byte_swap_32 (digest
[13]);
19085 digest
[14] = byte_swap_32 (digest
[14]);
19086 digest
[15] = byte_swap_32 (digest
[15]);
19088 return (PARSER_OK
);
19091 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19093 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19095 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19097 u32
*digest
= (u32
*) hash_buf
->digest
;
19099 salt_t
*salt
= hash_buf
->salt
;
19101 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19109 char *iter_pos
= input_buf
+ 4;
19111 u32 iter
= atoi (iter_pos
);
19113 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19114 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19116 // first is *raw* salt
19118 char *salt_pos
= strchr (iter_pos
, ':');
19120 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19124 char *hash_pos
= strchr (salt_pos
, ':');
19126 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19128 u32 salt_len
= hash_pos
- salt_pos
;
19130 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19134 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19136 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19140 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19142 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19144 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19146 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19147 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19149 salt
->salt_len
= salt_len
;
19150 salt
->salt_iter
= iter
- 1;
19154 u8 tmp_buf
[100] = { 0 };
19156 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19158 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19160 memcpy (digest
, tmp_buf
, 16);
19162 // add some stuff to normal salt to make sorted happy
19164 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19165 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19166 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19167 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19168 salt
->salt_buf
[4] = salt
->salt_iter
;
19170 return (PARSER_OK
);
19173 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19175 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19177 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19179 u32
*digest
= (u32
*) hash_buf
->digest
;
19181 salt_t
*salt
= hash_buf
->salt
;
19183 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19191 char *iter_pos
= input_buf
+ 5;
19193 u32 iter
= atoi (iter_pos
);
19195 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19196 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19198 // first is *raw* salt
19200 char *salt_pos
= strchr (iter_pos
, ':');
19202 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19206 char *hash_pos
= strchr (salt_pos
, ':');
19208 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19210 u32 salt_len
= hash_pos
- salt_pos
;
19212 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19216 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19218 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19222 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19224 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19226 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19228 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19229 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19231 salt
->salt_len
= salt_len
;
19232 salt
->salt_iter
= iter
- 1;
19236 u8 tmp_buf
[100] = { 0 };
19238 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19240 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19242 memcpy (digest
, tmp_buf
, 16);
19244 digest
[0] = byte_swap_32 (digest
[0]);
19245 digest
[1] = byte_swap_32 (digest
[1]);
19246 digest
[2] = byte_swap_32 (digest
[2]);
19247 digest
[3] = byte_swap_32 (digest
[3]);
19249 // add some stuff to normal salt to make sorted happy
19251 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19252 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19253 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19254 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19255 salt
->salt_buf
[4] = salt
->salt_iter
;
19257 return (PARSER_OK
);
19260 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19262 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19264 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19266 u64
*digest
= (u64
*) hash_buf
->digest
;
19268 salt_t
*salt
= hash_buf
->salt
;
19270 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19278 char *iter_pos
= input_buf
+ 7;
19280 u32 iter
= atoi (iter_pos
);
19282 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19283 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19285 // first is *raw* salt
19287 char *salt_pos
= strchr (iter_pos
, ':');
19289 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19293 char *hash_pos
= strchr (salt_pos
, ':');
19295 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19297 u32 salt_len
= hash_pos
- salt_pos
;
19299 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19303 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19305 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19309 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19311 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19313 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19315 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19316 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19318 salt
->salt_len
= salt_len
;
19319 salt
->salt_iter
= iter
- 1;
19323 u8 tmp_buf
[100] = { 0 };
19325 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19327 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19329 memcpy (digest
, tmp_buf
, 64);
19331 digest
[0] = byte_swap_64 (digest
[0]);
19332 digest
[1] = byte_swap_64 (digest
[1]);
19333 digest
[2] = byte_swap_64 (digest
[2]);
19334 digest
[3] = byte_swap_64 (digest
[3]);
19335 digest
[4] = byte_swap_64 (digest
[4]);
19336 digest
[5] = byte_swap_64 (digest
[5]);
19337 digest
[6] = byte_swap_64 (digest
[6]);
19338 digest
[7] = byte_swap_64 (digest
[7]);
19340 // add some stuff to normal salt to make sorted happy
19342 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19343 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19344 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19345 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19346 salt
->salt_buf
[4] = salt
->salt_iter
;
19348 return (PARSER_OK
);
19351 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19353 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19355 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19357 uint
*digest
= (uint
*) hash_buf
->digest
;
19359 salt_t
*salt
= hash_buf
->salt
;
19365 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19367 char *hash_pos
= strchr (salt_pos
, '$');
19369 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19371 u32 salt_len
= hash_pos
- salt_pos
;
19373 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19377 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19379 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19383 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19384 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19402 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19403 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19405 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19406 salt
->salt_len
= 8;
19408 return (PARSER_OK
);
19411 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19413 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19415 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19417 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19419 if (c19
& 3) return (PARSER_HASH_VALUE
);
19421 salt_t
*salt
= hash_buf
->salt
;
19423 u32
*digest
= (u32
*) hash_buf
->digest
;
19427 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19428 | itoa64_to_int (input_buf
[2]) << 6
19429 | itoa64_to_int (input_buf
[3]) << 12
19430 | itoa64_to_int (input_buf
[4]) << 18;
19434 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19435 | itoa64_to_int (input_buf
[6]) << 6
19436 | itoa64_to_int (input_buf
[7]) << 12
19437 | itoa64_to_int (input_buf
[8]) << 18;
19439 salt
->salt_len
= 4;
19441 u8 tmp_buf
[100] = { 0 };
19443 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19445 memcpy (digest
, tmp_buf
, 8);
19449 IP (digest
[0], digest
[1], tt
);
19451 digest
[0] = rotr32 (digest
[0], 31);
19452 digest
[1] = rotr32 (digest
[1], 31);
19456 return (PARSER_OK
);
19459 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19461 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19463 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19465 u32
*digest
= (u32
*) hash_buf
->digest
;
19467 salt_t
*salt
= hash_buf
->salt
;
19473 char *type_pos
= input_buf
+ 6 + 1;
19475 char *salt_pos
= strchr (type_pos
, '*');
19477 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19479 u32 type_len
= salt_pos
- type_pos
;
19481 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19485 char *crypted_pos
= strchr (salt_pos
, '*');
19487 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19489 u32 salt_len
= crypted_pos
- salt_pos
;
19491 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19495 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19497 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19503 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19504 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19506 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19507 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19509 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19510 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19511 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19512 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19514 salt
->salt_len
= 24;
19515 salt
->salt_iter
= ROUNDS_RAR3
;
19517 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19518 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19520 digest
[0] = 0xc43d7b00;
19521 digest
[1] = 0x40070000;
19525 return (PARSER_OK
);
19528 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19530 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19532 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19534 u32
*digest
= (u32
*) hash_buf
->digest
;
19536 salt_t
*salt
= hash_buf
->salt
;
19538 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19544 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19546 char *param1_pos
= strchr (param0_pos
, '$');
19548 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19550 u32 param0_len
= param1_pos
- param0_pos
;
19554 char *param2_pos
= strchr (param1_pos
, '$');
19556 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19558 u32 param1_len
= param2_pos
- param1_pos
;
19562 char *param3_pos
= strchr (param2_pos
, '$');
19564 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19566 u32 param2_len
= param3_pos
- param2_pos
;
19570 char *param4_pos
= strchr (param3_pos
, '$');
19572 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19574 u32 param3_len
= param4_pos
- param3_pos
;
19578 char *param5_pos
= strchr (param4_pos
, '$');
19580 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19582 u32 param4_len
= param5_pos
- param4_pos
;
19586 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19588 char *salt_buf
= param1_pos
;
19589 char *iv
= param3_pos
;
19590 char *pswcheck
= param5_pos
;
19592 const uint salt_len
= atoi (param0_pos
);
19593 const uint iterations
= atoi (param2_pos
);
19594 const uint pswcheck_len
= atoi (param4_pos
);
19600 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19601 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19602 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19604 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19605 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19606 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19612 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19613 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19614 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19615 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19617 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19618 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19619 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19620 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19622 salt
->salt_len
= 16;
19624 salt
->salt_sign
[0] = iterations
;
19626 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19632 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19633 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19637 return (PARSER_OK
);
19640 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19642 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19644 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19646 u32
*digest
= (u32
*) hash_buf
->digest
;
19648 salt_t
*salt
= hash_buf
->salt
;
19650 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19657 char *account_pos
= input_buf
+ 11 + 1;
19663 if (account_pos
[0] == '*')
19667 data_pos
= strchr (account_pos
, '*');
19672 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19674 uint account_len
= data_pos
- account_pos
+ 1;
19676 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19681 data_len
= input_len
- 11 - 1 - account_len
- 2;
19683 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19687 /* assume $krb5tgs$23$checksum$edata2 */
19688 data_pos
= account_pos
;
19690 memcpy (krb5tgs
->account_info
, "**", 3);
19692 data_len
= input_len
- 11 - 1 - 1;
19695 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19697 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19699 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19701 const char p0
= data_pos
[i
+ 0];
19702 const char p1
= data_pos
[i
+ 1];
19704 *checksum_ptr
++ = hex_convert (p1
) << 0
19705 | hex_convert (p0
) << 4;
19708 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19710 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19713 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19715 const char p0
= data_pos
[i
+ 0];
19716 const char p1
= data_pos
[i
+ 1];
19717 *edata_ptr
++ = hex_convert (p1
) << 0
19718 | hex_convert (p0
) << 4;
19721 /* this is needed for hmac_md5 */
19722 *edata_ptr
++ = 0x80;
19724 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19725 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19726 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19727 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19729 salt
->salt_len
= 32;
19731 digest
[0] = krb5tgs
->checksum
[0];
19732 digest
[1] = krb5tgs
->checksum
[1];
19733 digest
[2] = krb5tgs
->checksum
[2];
19734 digest
[3] = krb5tgs
->checksum
[3];
19736 return (PARSER_OK
);
19739 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19741 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19743 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19745 u32
*digest
= (u32
*) hash_buf
->digest
;
19747 salt_t
*salt
= hash_buf
->salt
;
19754 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19758 char *wrapped_key_pos
;
19762 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19764 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19766 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19768 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19773 data_pos
= salt_pos
;
19775 wrapped_key_pos
= strchr (salt_pos
, '*');
19777 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19779 uint salt_len
= wrapped_key_pos
- salt_pos
;
19781 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19786 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19788 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19790 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19791 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19792 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19793 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19797 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19798 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19799 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19800 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19801 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19802 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19804 salt
->salt_len
= 40;
19806 digest
[0] = salt
->salt_buf
[0];
19807 digest
[1] = salt
->salt_buf
[1];
19808 digest
[2] = salt
->salt_buf
[2];
19809 digest
[3] = salt
->salt_buf
[3];
19811 return (PARSER_OK
);
19814 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19816 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19818 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19820 u32
*digest
= (u32
*) hash_buf
->digest
;
19822 salt_t
*salt
= hash_buf
->salt
;
19824 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19834 char *algorithm_pos
;
19836 char *final_random_seed_pos
;
19837 u32 final_random_seed_len
;
19839 char *transf_random_seed_pos
;
19840 u32 transf_random_seed_len
;
19845 /* default is no keyfile provided */
19846 char *keyfile_len_pos
;
19847 u32 keyfile_len
= 0;
19848 u32 is_keyfile_present
= 0;
19849 char *keyfile_inline_pos
;
19852 /* specific to version 1 */
19853 char *contents_len_pos
;
19855 char *contents_pos
;
19857 /* specific to version 2 */
19858 char *expected_bytes_pos
;
19859 u32 expected_bytes_len
;
19861 char *contents_hash_pos
;
19862 u32 contents_hash_len
;
19864 version_pos
= input_buf
+ 8 + 1 + 1;
19866 keepass
->version
= atoi (version_pos
);
19868 rounds_pos
= strchr (version_pos
, '*');
19870 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19874 salt
->salt_iter
= (atoi (rounds_pos
));
19876 algorithm_pos
= strchr (rounds_pos
, '*');
19878 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19882 keepass
->algorithm
= atoi (algorithm_pos
);
19884 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19886 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19888 final_random_seed_pos
++;
19890 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19891 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19892 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19893 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19895 if (keepass
->version
== 2)
19897 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19898 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19899 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19900 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19903 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19905 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19907 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19909 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19910 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19912 transf_random_seed_pos
++;
19914 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19915 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19916 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19917 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19918 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19919 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19920 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19921 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19923 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19925 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19927 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19929 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19933 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19934 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19935 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19936 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19938 if (keepass
->version
== 1)
19940 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19942 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19944 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19946 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19948 contents_hash_pos
++;
19950 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19951 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19952 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19953 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19954 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19955 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19956 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19957 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19959 /* get length of contents following */
19960 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19962 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19964 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19966 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19970 u32 inline_flag
= atoi (inline_flag_pos
);
19972 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19974 contents_len_pos
= strchr (inline_flag_pos
, '*');
19976 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19978 contents_len_pos
++;
19980 contents_len
= atoi (contents_len_pos
);
19982 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19984 contents_pos
= strchr (contents_len_pos
, '*');
19986 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19992 keepass
->contents_len
= contents_len
;
19994 contents_len
= contents_len
/ 4;
19996 keyfile_inline_pos
= strchr (contents_pos
, '*');
19998 u32 real_contents_len
;
20000 if (keyfile_inline_pos
== NULL
)
20001 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20004 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20005 keyfile_inline_pos
++;
20006 is_keyfile_present
= 1;
20009 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20011 for (i
= 0; i
< contents_len
; i
++)
20012 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20014 else if (keepass
->version
== 2)
20016 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20018 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20020 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20022 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20024 expected_bytes_pos
++;
20026 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20027 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20028 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20029 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20030 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20031 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20032 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20033 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20035 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20037 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20039 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20041 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20043 contents_hash_pos
++;
20045 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20046 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20047 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20048 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20049 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20050 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20051 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20052 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20054 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20056 if (keyfile_inline_pos
== NULL
)
20057 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20060 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20061 keyfile_inline_pos
++;
20062 is_keyfile_present
= 1;
20064 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20067 if (is_keyfile_present
!= 0)
20069 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20073 keyfile_len
= atoi (keyfile_len_pos
);
20075 keepass
->keyfile_len
= keyfile_len
;
20077 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20079 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20081 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20085 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20087 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20089 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20090 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20091 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20092 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20093 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20094 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20095 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20096 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20099 digest
[0] = keepass
->enc_iv
[0];
20100 digest
[1] = keepass
->enc_iv
[1];
20101 digest
[2] = keepass
->enc_iv
[2];
20102 digest
[3] = keepass
->enc_iv
[3];
20104 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20105 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20106 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20107 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20108 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20109 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20110 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20111 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20113 return (PARSER_OK
);
20116 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20118 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20120 u32
*digest
= (u32
*) hash_buf
->digest
;
20122 salt_t
*salt
= hash_buf
->salt
;
20124 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20125 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20126 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20127 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20128 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20129 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20130 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20131 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20133 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20135 uint salt_len
= input_len
- 64 - 1;
20137 char *salt_buf
= input_buf
+ 64 + 1;
20139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20143 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20145 salt
->salt_len
= salt_len
;
20148 * we can precompute the first sha256 transform
20151 uint w
[16] = { 0 };
20153 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20154 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20155 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20156 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20157 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20158 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20159 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20160 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20161 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20162 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20163 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20164 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20165 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20166 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20167 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20168 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20170 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20172 sha256_64 (w
, pc256
);
20174 salt
->salt_buf_pc
[0] = pc256
[0];
20175 salt
->salt_buf_pc
[1] = pc256
[1];
20176 salt
->salt_buf_pc
[2] = pc256
[2];
20177 salt
->salt_buf_pc
[3] = pc256
[3];
20178 salt
->salt_buf_pc
[4] = pc256
[4];
20179 salt
->salt_buf_pc
[5] = pc256
[5];
20180 salt
->salt_buf_pc
[6] = pc256
[6];
20181 salt
->salt_buf_pc
[7] = pc256
[7];
20183 digest
[0] -= pc256
[0];
20184 digest
[1] -= pc256
[1];
20185 digest
[2] -= pc256
[2];
20186 digest
[3] -= pc256
[3];
20187 digest
[4] -= pc256
[4];
20188 digest
[5] -= pc256
[5];
20189 digest
[6] -= pc256
[6];
20190 digest
[7] -= pc256
[7];
20192 return (PARSER_OK
);
20195 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20197 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20199 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20201 u32
*digest
= (u32
*) hash_buf
->digest
;
20203 salt_t
*salt
= hash_buf
->salt
;
20209 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20211 char *data_buf_pos
= strchr (data_len_pos
, '$');
20213 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20215 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20217 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20218 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20222 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20224 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20226 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20228 u32 data_len
= atoi (data_len_pos
);
20230 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20236 char *salt_pos
= data_buf_pos
;
20238 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20239 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20240 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20241 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20243 // this is actually the CT, which is also the hash later (if matched)
20245 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20246 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20247 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20248 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20250 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20252 salt
->salt_iter
= 10 - 1;
20258 digest
[0] = salt
->salt_buf
[4];
20259 digest
[1] = salt
->salt_buf
[5];
20260 digest
[2] = salt
->salt_buf
[6];
20261 digest
[3] = salt
->salt_buf
[7];
20263 return (PARSER_OK
);
20266 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20268 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20270 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20272 u32
*digest
= (u32
*) hash_buf
->digest
;
20274 salt_t
*salt
= hash_buf
->salt
;
20280 char *salt_pos
= input_buf
+ 11 + 1;
20282 char *iter_pos
= strchr (salt_pos
, ',');
20284 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20286 u32 salt_len
= iter_pos
- salt_pos
;
20288 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20292 char *hash_pos
= strchr (iter_pos
, ',');
20294 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20296 u32 iter_len
= hash_pos
- iter_pos
;
20298 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20302 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20304 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20310 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20311 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20312 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20313 salt
->salt_buf
[3] = 0x00018000;
20315 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20316 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20317 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20318 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20320 salt
->salt_len
= salt_len
/ 2;
20322 salt
->salt_iter
= atoi (iter_pos
) - 1;
20328 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20329 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20330 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20331 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20332 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20333 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20334 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20335 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20337 return (PARSER_OK
);
20340 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20342 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20344 u32
*digest
= (u32
*) hash_buf
->digest
;
20346 salt_t
*salt
= hash_buf
->salt
;
20352 char *hash_pos
= input_buf
+ 64;
20353 char *salt1_pos
= input_buf
+ 128;
20354 char *salt2_pos
= input_buf
;
20360 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20361 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20362 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20363 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20365 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20366 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20367 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20368 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20370 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20371 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20372 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20373 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20375 salt
->salt_len
= 48;
20377 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20383 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20384 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20385 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20386 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20387 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20388 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20389 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20390 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20392 return (PARSER_OK
);
20395 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20397 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20399 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20400 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20402 u32
*digest
= (u32
*) hash_buf
->digest
;
20404 salt_t
*salt
= hash_buf
->salt
;
20406 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20412 char *param0_pos
= input_buf
+ 6 + 1;
20414 char *param1_pos
= strchr (param0_pos
, '*');
20416 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20418 u32 param0_len
= param1_pos
- param0_pos
;
20422 char *param2_pos
= strchr (param1_pos
, '*');
20424 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20426 u32 param1_len
= param2_pos
- param1_pos
;
20430 char *param3_pos
= strchr (param2_pos
, '*');
20432 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20434 u32 param2_len
= param3_pos
- param2_pos
;
20438 char *param4_pos
= strchr (param3_pos
, '*');
20440 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20442 u32 param3_len
= param4_pos
- param3_pos
;
20446 char *param5_pos
= strchr (param4_pos
, '*');
20448 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20450 u32 param4_len
= param5_pos
- param4_pos
;
20454 char *param6_pos
= strchr (param5_pos
, '*');
20456 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20458 u32 param5_len
= param6_pos
- param5_pos
;
20462 char *param7_pos
= strchr (param6_pos
, '*');
20464 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20466 u32 param6_len
= param7_pos
- param6_pos
;
20470 char *param8_pos
= strchr (param7_pos
, '*');
20472 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20474 u32 param7_len
= param8_pos
- param7_pos
;
20478 const uint type
= atoi (param0_pos
);
20479 const uint mode
= atoi (param1_pos
);
20480 const uint magic
= atoi (param2_pos
);
20482 char *salt_buf
= param3_pos
;
20484 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20486 const uint compress_length
= atoi (param5_pos
);
20488 char *data_buf
= param6_pos
;
20489 char *auth
= param7_pos
;
20495 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20497 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20499 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20501 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20503 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20505 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20507 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20509 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20511 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20513 if (type
!= 0) return (PARSER_SALT_VALUE
);
20515 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20517 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20519 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20527 zip2
->magic
= magic
;
20531 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20532 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20533 zip2
->salt_buf
[2] = 0;
20534 zip2
->salt_buf
[3] = 0;
20536 zip2
->salt_len
= 8;
20538 else if (mode
== 2)
20540 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20541 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20542 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20543 zip2
->salt_buf
[3] = 0;
20545 zip2
->salt_len
= 12;
20547 else if (mode
== 3)
20549 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20550 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20551 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20552 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20554 zip2
->salt_len
= 16;
20557 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20558 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20559 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20560 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20562 zip2
->verify_bytes
= verify_bytes
;
20564 zip2
->compress_length
= compress_length
;
20566 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20568 for (uint i
= 0; i
< param6_len
; i
+= 2)
20570 const char p0
= data_buf
[i
+ 0];
20571 const char p1
= data_buf
[i
+ 1];
20573 *data_buf_ptr
++ = hex_convert (p1
) << 0
20574 | hex_convert (p0
) << 4;
20579 *data_buf_ptr
= 0x80;
20581 char *auth_ptr
= (char *) zip2
->auth_buf
;
20583 for (uint i
= 0; i
< param7_len
; i
+= 2)
20585 const char p0
= auth
[i
+ 0];
20586 const char p1
= auth
[i
+ 1];
20588 *auth_ptr
++ = hex_convert (p1
) << 0
20589 | hex_convert (p0
) << 4;
20598 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20599 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20600 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20601 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20602 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20603 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20604 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20605 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20607 salt
->salt_len
= 32;
20609 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20612 * digest buf (fake)
20615 digest
[0] = zip2
->auth_buf
[0];
20616 digest
[1] = zip2
->auth_buf
[1];
20617 digest
[2] = zip2
->auth_buf
[2];
20618 digest
[3] = zip2
->auth_buf
[3];
20620 return (PARSER_OK
);
20623 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20625 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20627 u32
*digest
= (u32
*) hash_buf
->digest
;
20629 salt_t
*salt
= hash_buf
->salt
;
20631 win8phone_t
*esalt
= hash_buf
->esalt
;
20633 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20634 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20635 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20636 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20637 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20638 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20639 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20640 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20642 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20644 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20646 u32
*salt_buf
= esalt
->salt_buf
;
20648 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20650 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20653 salt
->salt_buf
[0] = salt_buf
[0];
20654 salt
->salt_buf
[1] = salt_buf
[1];
20655 salt
->salt_buf
[2] = salt_buf
[2];
20656 salt
->salt_buf
[3] = salt_buf
[3];
20657 salt
->salt_buf
[4] = salt_buf
[4];
20658 salt
->salt_buf
[5] = salt_buf
[5];
20659 salt
->salt_buf
[6] = salt_buf
[6];
20660 salt
->salt_buf
[7] = salt_buf
[7];
20662 salt
->salt_len
= 64;
20664 return (PARSER_OK
);
20668 * parallel running threads
20673 BOOL WINAPI
sigHandler_default (DWORD sig
)
20677 case CTRL_CLOSE_EVENT
:
20680 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20681 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20682 * function otherwise it is too late (e.g. after returning from this function)
20687 SetConsoleCtrlHandler (NULL
, TRUE
);
20694 case CTRL_LOGOFF_EVENT
:
20695 case CTRL_SHUTDOWN_EVENT
:
20699 SetConsoleCtrlHandler (NULL
, TRUE
);
20707 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20711 case CTRL_CLOSE_EVENT
:
20715 SetConsoleCtrlHandler (NULL
, TRUE
);
20722 case CTRL_LOGOFF_EVENT
:
20723 case CTRL_SHUTDOWN_EVENT
:
20727 SetConsoleCtrlHandler (NULL
, TRUE
);
20735 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20737 if (callback
== NULL
)
20739 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20743 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20749 void sigHandler_default (int sig
)
20753 signal (sig
, NULL
);
20756 void sigHandler_benchmark (int sig
)
20760 signal (sig
, NULL
);
20763 void hc_signal (void (callback
) (int))
20765 if (callback
== NULL
) callback
= SIG_DFL
;
20767 signal (SIGINT
, callback
);
20768 signal (SIGTERM
, callback
);
20769 signal (SIGABRT
, callback
);
20774 void status_display ();
20776 void *thread_keypress (void *p
)
20778 uint quiet
= data
.quiet
;
20782 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20784 int ch
= tty_getchar();
20786 if (ch
== -1) break;
20788 if (ch
== 0) continue;
20790 //https://github.com/hashcat/hashcat/issues/302
20795 hc_thread_mutex_lock (mux_display
);
20811 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20812 if (quiet
== 0) fflush (stdout
);
20824 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20825 if (quiet
== 0) fflush (stdout
);
20837 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20838 if (quiet
== 0) fflush (stdout
);
20850 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20851 if (quiet
== 0) fflush (stdout
);
20859 stop_at_checkpoint ();
20863 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20864 if (quiet
== 0) fflush (stdout
);
20877 //https://github.com/hashcat/hashcat/issues/302
20882 hc_thread_mutex_unlock (mux_display
);
20894 bool class_num (const u8 c
)
20896 return ((c
>= '0') && (c
<= '9'));
20899 bool class_lower (const u8 c
)
20901 return ((c
>= 'a') && (c
<= 'z'));
20904 bool class_upper (const u8 c
)
20906 return ((c
>= 'A') && (c
<= 'Z'));
20909 bool class_alpha (const u8 c
)
20911 return (class_lower (c
) || class_upper (c
));
20914 int conv_ctoi (const u8 c
)
20920 else if (class_upper (c
))
20922 return c
- 'A' + 10;
20928 int conv_itoc (const u8 c
)
20936 return c
+ 'A' - 10;
20946 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20947 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20948 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20949 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20950 #define MAX_KERNEL_RULES 255
20951 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20952 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20953 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20955 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20956 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20957 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20958 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20960 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20965 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20967 switch (rule_buf
[rule_pos
])
20973 case RULE_OP_MANGLE_NOOP
:
20974 SET_NAME (rule
, rule_buf
[rule_pos
]);
20977 case RULE_OP_MANGLE_LREST
:
20978 SET_NAME (rule
, rule_buf
[rule_pos
]);
20981 case RULE_OP_MANGLE_UREST
:
20982 SET_NAME (rule
, rule_buf
[rule_pos
]);
20985 case RULE_OP_MANGLE_LREST_UFIRST
:
20986 SET_NAME (rule
, rule_buf
[rule_pos
]);
20989 case RULE_OP_MANGLE_UREST_LFIRST
:
20990 SET_NAME (rule
, rule_buf
[rule_pos
]);
20993 case RULE_OP_MANGLE_TREST
:
20994 SET_NAME (rule
, rule_buf
[rule_pos
]);
20997 case RULE_OP_MANGLE_TOGGLE_AT
:
20998 SET_NAME (rule
, rule_buf
[rule_pos
]);
20999 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21002 case RULE_OP_MANGLE_REVERSE
:
21003 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 case RULE_OP_MANGLE_DUPEWORD
:
21007 SET_NAME (rule
, rule_buf
[rule_pos
]);
21010 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21011 SET_NAME (rule
, rule_buf
[rule_pos
]);
21012 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21015 case RULE_OP_MANGLE_REFLECT
:
21016 SET_NAME (rule
, rule_buf
[rule_pos
]);
21019 case RULE_OP_MANGLE_ROTATE_LEFT
:
21020 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21024 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 case RULE_OP_MANGLE_APPEND
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21029 SET_P0 (rule
, rule_buf
[rule_pos
]);
21032 case RULE_OP_MANGLE_PREPEND
:
21033 SET_NAME (rule
, rule_buf
[rule_pos
]);
21034 SET_P0 (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_DELETE_FIRST
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_DELETE_LAST
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21045 case RULE_OP_MANGLE_DELETE_AT
:
21046 SET_NAME (rule
, rule_buf
[rule_pos
]);
21047 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_EXTRACT
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21052 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21053 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21056 case RULE_OP_MANGLE_OMIT
:
21057 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21059 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21062 case RULE_OP_MANGLE_INSERT
:
21063 SET_NAME (rule
, rule_buf
[rule_pos
]);
21064 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21065 SET_P1 (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_OVERSTRIKE
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21070 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21071 SET_P1 (rule
, rule_buf
[rule_pos
]);
21074 case RULE_OP_MANGLE_TRUNCATE_AT
:
21075 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21079 case RULE_OP_MANGLE_REPLACE
:
21080 SET_NAME (rule
, rule_buf
[rule_pos
]);
21081 SET_P0 (rule
, rule_buf
[rule_pos
]);
21082 SET_P1 (rule
, rule_buf
[rule_pos
]);
21085 case RULE_OP_MANGLE_PURGECHAR
:
21089 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21093 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21094 SET_NAME (rule
, rule_buf
[rule_pos
]);
21095 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21098 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21099 SET_NAME (rule
, rule_buf
[rule_pos
]);
21100 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21103 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21104 SET_NAME (rule
, rule_buf
[rule_pos
]);
21107 case RULE_OP_MANGLE_SWITCH_FIRST
:
21108 SET_NAME (rule
, rule_buf
[rule_pos
]);
21111 case RULE_OP_MANGLE_SWITCH_LAST
:
21112 SET_NAME (rule
, rule_buf
[rule_pos
]);
21115 case RULE_OP_MANGLE_SWITCH_AT
:
21116 SET_NAME (rule
, rule_buf
[rule_pos
]);
21117 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21118 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21121 case RULE_OP_MANGLE_CHR_SHIFTL
:
21122 SET_NAME (rule
, rule_buf
[rule_pos
]);
21123 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21126 case RULE_OP_MANGLE_CHR_SHIFTR
:
21127 SET_NAME (rule
, rule_buf
[rule_pos
]);
21128 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21131 case RULE_OP_MANGLE_CHR_INCR
:
21132 SET_NAME (rule
, rule_buf
[rule_pos
]);
21133 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21136 case RULE_OP_MANGLE_CHR_DECR
:
21137 SET_NAME (rule
, rule_buf
[rule_pos
]);
21138 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21141 case RULE_OP_MANGLE_REPLACE_NP1
:
21142 SET_NAME (rule
, rule_buf
[rule_pos
]);
21143 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21146 case RULE_OP_MANGLE_REPLACE_NM1
:
21147 SET_NAME (rule
, rule_buf
[rule_pos
]);
21148 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21151 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21152 SET_NAME (rule
, rule_buf
[rule_pos
]);
21153 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21156 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21157 SET_NAME (rule
, rule_buf
[rule_pos
]);
21158 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21161 case RULE_OP_MANGLE_TITLE
:
21162 SET_NAME (rule
, rule_buf
[rule_pos
]);
21171 if (rule_pos
< rule_len
) return (-1);
21176 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21180 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21184 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21188 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21192 case RULE_OP_MANGLE_NOOP
:
21193 rule_buf
[rule_pos
] = rule_cmd
;
21196 case RULE_OP_MANGLE_LREST
:
21197 rule_buf
[rule_pos
] = rule_cmd
;
21200 case RULE_OP_MANGLE_UREST
:
21201 rule_buf
[rule_pos
] = rule_cmd
;
21204 case RULE_OP_MANGLE_LREST_UFIRST
:
21205 rule_buf
[rule_pos
] = rule_cmd
;
21208 case RULE_OP_MANGLE_UREST_LFIRST
:
21209 rule_buf
[rule_pos
] = rule_cmd
;
21212 case RULE_OP_MANGLE_TREST
:
21213 rule_buf
[rule_pos
] = rule_cmd
;
21216 case RULE_OP_MANGLE_TOGGLE_AT
:
21217 rule_buf
[rule_pos
] = rule_cmd
;
21218 GET_P0_CONV (rule
);
21221 case RULE_OP_MANGLE_REVERSE
:
21222 rule_buf
[rule_pos
] = rule_cmd
;
21225 case RULE_OP_MANGLE_DUPEWORD
:
21226 rule_buf
[rule_pos
] = rule_cmd
;
21229 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21230 rule_buf
[rule_pos
] = rule_cmd
;
21231 GET_P0_CONV (rule
);
21234 case RULE_OP_MANGLE_REFLECT
:
21235 rule_buf
[rule_pos
] = rule_cmd
;
21238 case RULE_OP_MANGLE_ROTATE_LEFT
:
21239 rule_buf
[rule_pos
] = rule_cmd
;
21242 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21243 rule_buf
[rule_pos
] = rule_cmd
;
21246 case RULE_OP_MANGLE_APPEND
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21251 case RULE_OP_MANGLE_PREPEND
:
21252 rule_buf
[rule_pos
] = rule_cmd
;
21256 case RULE_OP_MANGLE_DELETE_FIRST
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21260 case RULE_OP_MANGLE_DELETE_LAST
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21264 case RULE_OP_MANGLE_DELETE_AT
:
21265 rule_buf
[rule_pos
] = rule_cmd
;
21266 GET_P0_CONV (rule
);
21269 case RULE_OP_MANGLE_EXTRACT
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21271 GET_P0_CONV (rule
);
21272 GET_P1_CONV (rule
);
21275 case RULE_OP_MANGLE_OMIT
:
21276 rule_buf
[rule_pos
] = rule_cmd
;
21277 GET_P0_CONV (rule
);
21278 GET_P1_CONV (rule
);
21281 case RULE_OP_MANGLE_INSERT
:
21282 rule_buf
[rule_pos
] = rule_cmd
;
21283 GET_P0_CONV (rule
);
21287 case RULE_OP_MANGLE_OVERSTRIKE
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21289 GET_P0_CONV (rule
);
21293 case RULE_OP_MANGLE_TRUNCATE_AT
:
21294 rule_buf
[rule_pos
] = rule_cmd
;
21295 GET_P0_CONV (rule
);
21298 case RULE_OP_MANGLE_REPLACE
:
21299 rule_buf
[rule_pos
] = rule_cmd
;
21304 case RULE_OP_MANGLE_PURGECHAR
:
21308 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21312 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21313 rule_buf
[rule_pos
] = rule_cmd
;
21314 GET_P0_CONV (rule
);
21317 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21318 rule_buf
[rule_pos
] = rule_cmd
;
21319 GET_P0_CONV (rule
);
21322 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21323 rule_buf
[rule_pos
] = rule_cmd
;
21326 case RULE_OP_MANGLE_SWITCH_FIRST
:
21327 rule_buf
[rule_pos
] = rule_cmd
;
21330 case RULE_OP_MANGLE_SWITCH_LAST
:
21331 rule_buf
[rule_pos
] = rule_cmd
;
21334 case RULE_OP_MANGLE_SWITCH_AT
:
21335 rule_buf
[rule_pos
] = rule_cmd
;
21336 GET_P0_CONV (rule
);
21337 GET_P1_CONV (rule
);
21340 case RULE_OP_MANGLE_CHR_SHIFTL
:
21341 rule_buf
[rule_pos
] = rule_cmd
;
21342 GET_P0_CONV (rule
);
21345 case RULE_OP_MANGLE_CHR_SHIFTR
:
21346 rule_buf
[rule_pos
] = rule_cmd
;
21347 GET_P0_CONV (rule
);
21350 case RULE_OP_MANGLE_CHR_INCR
:
21351 rule_buf
[rule_pos
] = rule_cmd
;
21352 GET_P0_CONV (rule
);
21355 case RULE_OP_MANGLE_CHR_DECR
:
21356 rule_buf
[rule_pos
] = rule_cmd
;
21357 GET_P0_CONV (rule
);
21360 case RULE_OP_MANGLE_REPLACE_NP1
:
21361 rule_buf
[rule_pos
] = rule_cmd
;
21362 GET_P0_CONV (rule
);
21365 case RULE_OP_MANGLE_REPLACE_NM1
:
21366 rule_buf
[rule_pos
] = rule_cmd
;
21367 GET_P0_CONV (rule
);
21370 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21371 rule_buf
[rule_pos
] = rule_cmd
;
21372 GET_P0_CONV (rule
);
21375 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21376 rule_buf
[rule_pos
] = rule_cmd
;
21377 GET_P0_CONV (rule
);
21380 case RULE_OP_MANGLE_TITLE
:
21381 rule_buf
[rule_pos
] = rule_cmd
;
21385 return rule_pos
- 1;
21403 * CPU rules : this is from hashcat sources, cpu based rules
21406 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21407 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21409 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21410 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21411 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21413 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21414 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21415 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21417 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21421 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21426 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21430 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21435 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21439 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21444 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21449 for (l
= 0; l
< arr_len
; l
++)
21451 r
= arr_len
- 1 - l
;
21455 MANGLE_SWITCH (arr
, l
, r
);
21461 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21463 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21465 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21467 return (arr_len
* 2);
21470 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21472 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21474 int orig_len
= arr_len
;
21478 for (i
= 0; i
< times
; i
++)
21480 memcpy (&arr
[arr_len
], arr
, orig_len
);
21482 arr_len
+= orig_len
;
21488 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21490 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21492 mangle_double (arr
, arr_len
);
21494 mangle_reverse (arr
+ arr_len
, arr_len
);
21496 return (arr_len
* 2);
21499 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21504 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21506 MANGLE_SWITCH (arr
, l
, r
);
21512 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21517 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21519 MANGLE_SWITCH (arr
, l
, r
);
21525 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21527 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21531 return (arr_len
+ 1);
21534 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21536 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21540 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21542 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21547 return (arr_len
+ 1);
21550 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21552 if (upos
>= arr_len
) return (arr_len
);
21556 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21558 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21561 return (arr_len
- 1);
21564 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21566 if (upos
>= arr_len
) return (arr_len
);
21568 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21572 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21574 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21580 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21582 if (upos
>= arr_len
) return (arr_len
);
21584 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21588 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21590 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21593 return (arr_len
- ulen
);
21596 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21598 if (upos
>= arr_len
) return (arr_len
);
21600 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21604 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21606 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21611 return (arr_len
+ 1);
21614 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
)
21616 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21618 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21620 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21622 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21624 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21626 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21628 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21630 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21632 return (arr_len
+ arr2_cpy
);
21635 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21637 if (upos
>= arr_len
) return (arr_len
);
21644 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21646 if (upos
>= arr_len
) return (arr_len
);
21648 memset (arr
+ upos
, 0, arr_len
- upos
);
21653 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21657 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21659 if (arr
[arr_pos
] != oldc
) continue;
21661 arr
[arr_pos
] = newc
;
21667 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21673 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21675 if (arr
[arr_pos
] == c
) continue;
21677 arr
[ret_len
] = arr
[arr_pos
];
21685 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21687 if (ulen
> arr_len
) return (arr_len
);
21689 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21691 char cs
[100] = { 0 };
21693 memcpy (cs
, arr
, ulen
);
21697 for (i
= 0; i
< ulen
; i
++)
21701 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21707 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21709 if (ulen
> arr_len
) return (arr_len
);
21711 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21713 int upos
= arr_len
- ulen
;
21717 for (i
= 0; i
< ulen
; i
++)
21719 char c
= arr
[upos
+ i
];
21721 arr_len
= mangle_append (arr
, arr_len
, c
);
21727 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21729 if ( arr_len
== 0) return (arr_len
);
21730 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21732 char c
= arr
[upos
];
21736 for (i
= 0; i
< ulen
; i
++)
21738 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21744 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21746 if ( arr_len
== 0) return (arr_len
);
21747 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21751 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21753 int new_pos
= arr_pos
* 2;
21755 arr
[new_pos
] = arr
[arr_pos
];
21757 arr
[new_pos
+ 1] = arr
[arr_pos
];
21760 return (arr_len
* 2);
21763 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21765 if (upos
>= arr_len
) return (arr_len
);
21766 if (upos2
>= arr_len
) return (arr_len
);
21768 MANGLE_SWITCH (arr
, upos
, upos2
);
21773 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21775 MANGLE_SWITCH (arr
, upos
, upos2
);
21780 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21782 if (upos
>= arr_len
) return (arr_len
);
21789 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21791 if (upos
>= arr_len
) return (arr_len
);
21798 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21800 if (upos
>= arr_len
) return (arr_len
);
21807 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21809 if (upos
>= arr_len
) return (arr_len
);
21816 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21818 int upper_next
= 1;
21822 for (pos
= 0; pos
< arr_len
; pos
++)
21824 if (arr
[pos
] == ' ')
21835 MANGLE_UPPER_AT (arr
, pos
);
21839 MANGLE_LOWER_AT (arr
, pos
);
21846 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21848 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21854 for (j
= 0; j
< rp_gen_num
; j
++)
21861 switch ((char) get_random_num (0, 9))
21864 r
= get_random_num (0, sizeof (grp_op_nop
));
21865 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21869 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21870 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21871 p1
= get_random_num (0, sizeof (grp_pos
));
21872 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21876 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21877 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21878 p1
= get_random_num (1, 6);
21879 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21883 r
= get_random_num (0, sizeof (grp_op_chr
));
21884 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21885 p1
= get_random_num (0x20, 0x7e);
21886 rule_buf
[rule_pos
++] = (char) p1
;
21890 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21891 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21892 p1
= get_random_num (0x20, 0x7e);
21893 rule_buf
[rule_pos
++] = (char) p1
;
21894 p2
= get_random_num (0x20, 0x7e);
21896 p2
= get_random_num (0x20, 0x7e);
21897 rule_buf
[rule_pos
++] = (char) p2
;
21901 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21902 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21903 p1
= get_random_num (0, sizeof (grp_pos
));
21904 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21905 p2
= get_random_num (0x20, 0x7e);
21906 rule_buf
[rule_pos
++] = (char) p2
;
21910 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21911 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21912 p1
= get_random_num (0, sizeof (grp_pos
));
21913 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21914 p2
= get_random_num (0, sizeof (grp_pos
));
21916 p2
= get_random_num (0, sizeof (grp_pos
));
21917 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21921 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21922 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21923 p1
= get_random_num (0, sizeof (grp_pos
));
21924 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21925 p2
= get_random_num (1, sizeof (grp_pos
));
21927 p2
= get_random_num (1, sizeof (grp_pos
));
21928 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21932 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21933 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21934 p1
= get_random_num (0, sizeof (grp_pos
));
21935 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21936 p2
= get_random_num (1, sizeof (grp_pos
));
21937 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21938 p3
= get_random_num (0, sizeof (grp_pos
));
21939 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21947 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21949 char mem
[BLOCK_SIZE
] = { 0 };
21951 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21953 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21955 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21957 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21959 int out_len
= in_len
;
21960 int mem_len
= in_len
;
21962 memcpy (out
, in
, out_len
);
21966 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21971 switch (rule
[rule_pos
])
21976 case RULE_OP_MANGLE_NOOP
:
21979 case RULE_OP_MANGLE_LREST
:
21980 out_len
= mangle_lrest (out
, out_len
);
21983 case RULE_OP_MANGLE_UREST
:
21984 out_len
= mangle_urest (out
, out_len
);
21987 case RULE_OP_MANGLE_LREST_UFIRST
:
21988 out_len
= mangle_lrest (out
, out_len
);
21989 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21992 case RULE_OP_MANGLE_UREST_LFIRST
:
21993 out_len
= mangle_urest (out
, out_len
);
21994 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21997 case RULE_OP_MANGLE_TREST
:
21998 out_len
= mangle_trest (out
, out_len
);
22001 case RULE_OP_MANGLE_TOGGLE_AT
:
22002 NEXT_RULEPOS (rule_pos
);
22003 NEXT_RPTOI (rule
, rule_pos
, upos
);
22004 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22007 case RULE_OP_MANGLE_REVERSE
:
22008 out_len
= mangle_reverse (out
, out_len
);
22011 case RULE_OP_MANGLE_DUPEWORD
:
22012 out_len
= mangle_double (out
, out_len
);
22015 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22016 NEXT_RULEPOS (rule_pos
);
22017 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22018 out_len
= mangle_double_times (out
, out_len
, ulen
);
22021 case RULE_OP_MANGLE_REFLECT
:
22022 out_len
= mangle_reflect (out
, out_len
);
22025 case RULE_OP_MANGLE_ROTATE_LEFT
:
22026 mangle_rotate_left (out
, out_len
);
22029 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22030 mangle_rotate_right (out
, out_len
);
22033 case RULE_OP_MANGLE_APPEND
:
22034 NEXT_RULEPOS (rule_pos
);
22035 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22038 case RULE_OP_MANGLE_PREPEND
:
22039 NEXT_RULEPOS (rule_pos
);
22040 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22043 case RULE_OP_MANGLE_DELETE_FIRST
:
22044 out_len
= mangle_delete_at (out
, out_len
, 0);
22047 case RULE_OP_MANGLE_DELETE_LAST
:
22048 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22051 case RULE_OP_MANGLE_DELETE_AT
:
22052 NEXT_RULEPOS (rule_pos
);
22053 NEXT_RPTOI (rule
, rule_pos
, upos
);
22054 out_len
= mangle_delete_at (out
, out_len
, upos
);
22057 case RULE_OP_MANGLE_EXTRACT
:
22058 NEXT_RULEPOS (rule_pos
);
22059 NEXT_RPTOI (rule
, rule_pos
, upos
);
22060 NEXT_RULEPOS (rule_pos
);
22061 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22062 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22065 case RULE_OP_MANGLE_OMIT
:
22066 NEXT_RULEPOS (rule_pos
);
22067 NEXT_RPTOI (rule
, rule_pos
, upos
);
22068 NEXT_RULEPOS (rule_pos
);
22069 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22070 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22073 case RULE_OP_MANGLE_INSERT
:
22074 NEXT_RULEPOS (rule_pos
);
22075 NEXT_RPTOI (rule
, rule_pos
, upos
);
22076 NEXT_RULEPOS (rule_pos
);
22077 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22080 case RULE_OP_MANGLE_OVERSTRIKE
:
22081 NEXT_RULEPOS (rule_pos
);
22082 NEXT_RPTOI (rule
, rule_pos
, upos
);
22083 NEXT_RULEPOS (rule_pos
);
22084 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22087 case RULE_OP_MANGLE_TRUNCATE_AT
:
22088 NEXT_RULEPOS (rule_pos
);
22089 NEXT_RPTOI (rule
, rule_pos
, upos
);
22090 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22093 case RULE_OP_MANGLE_REPLACE
:
22094 NEXT_RULEPOS (rule_pos
);
22095 NEXT_RULEPOS (rule_pos
);
22096 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22099 case RULE_OP_MANGLE_PURGECHAR
:
22100 NEXT_RULEPOS (rule_pos
);
22101 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22104 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22108 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22109 NEXT_RULEPOS (rule_pos
);
22110 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22111 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22114 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22115 NEXT_RULEPOS (rule_pos
);
22116 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22117 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22120 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22121 out_len
= mangle_dupechar (out
, out_len
);
22124 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22125 NEXT_RULEPOS (rule_pos
);
22126 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22127 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22130 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22131 NEXT_RULEPOS (rule_pos
);
22132 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22133 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22136 case RULE_OP_MANGLE_SWITCH_FIRST
:
22137 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22140 case RULE_OP_MANGLE_SWITCH_LAST
:
22141 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22144 case RULE_OP_MANGLE_SWITCH_AT
:
22145 NEXT_RULEPOS (rule_pos
);
22146 NEXT_RPTOI (rule
, rule_pos
, upos
);
22147 NEXT_RULEPOS (rule_pos
);
22148 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22149 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22152 case RULE_OP_MANGLE_CHR_SHIFTL
:
22153 NEXT_RULEPOS (rule_pos
);
22154 NEXT_RPTOI (rule
, rule_pos
, upos
);
22155 mangle_chr_shiftl (out
, out_len
, upos
);
22158 case RULE_OP_MANGLE_CHR_SHIFTR
:
22159 NEXT_RULEPOS (rule_pos
);
22160 NEXT_RPTOI (rule
, rule_pos
, upos
);
22161 mangle_chr_shiftr (out
, out_len
, upos
);
22164 case RULE_OP_MANGLE_CHR_INCR
:
22165 NEXT_RULEPOS (rule_pos
);
22166 NEXT_RPTOI (rule
, rule_pos
, upos
);
22167 mangle_chr_incr (out
, out_len
, upos
);
22170 case RULE_OP_MANGLE_CHR_DECR
:
22171 NEXT_RULEPOS (rule_pos
);
22172 NEXT_RPTOI (rule
, rule_pos
, upos
);
22173 mangle_chr_decr (out
, out_len
, upos
);
22176 case RULE_OP_MANGLE_REPLACE_NP1
:
22177 NEXT_RULEPOS (rule_pos
);
22178 NEXT_RPTOI (rule
, rule_pos
, upos
);
22179 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22182 case RULE_OP_MANGLE_REPLACE_NM1
:
22183 NEXT_RULEPOS (rule_pos
);
22184 NEXT_RPTOI (rule
, rule_pos
, upos
);
22185 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22188 case RULE_OP_MANGLE_TITLE
:
22189 out_len
= mangle_title (out
, out_len
);
22192 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22193 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22194 NEXT_RULEPOS (rule_pos
);
22195 NEXT_RPTOI (rule
, rule_pos
, upos
);
22196 NEXT_RULEPOS (rule_pos
);
22197 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22198 NEXT_RULEPOS (rule_pos
);
22199 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22200 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22203 case RULE_OP_MANGLE_APPEND_MEMORY
:
22204 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22205 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22206 memcpy (out
+ out_len
, mem
, mem_len
);
22207 out_len
+= mem_len
;
22210 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22211 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22212 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22213 memcpy (mem
+ mem_len
, out
, out_len
);
22214 out_len
+= mem_len
;
22215 memcpy (out
, mem
, out_len
);
22218 case RULE_OP_MEMORIZE_WORD
:
22219 memcpy (mem
, out
, out_len
);
22223 case RULE_OP_REJECT_LESS
:
22224 NEXT_RULEPOS (rule_pos
);
22225 NEXT_RPTOI (rule
, rule_pos
, upos
);
22226 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22229 case RULE_OP_REJECT_GREATER
:
22230 NEXT_RULEPOS (rule_pos
);
22231 NEXT_RPTOI (rule
, rule_pos
, upos
);
22232 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22235 case RULE_OP_REJECT_CONTAIN
:
22236 NEXT_RULEPOS (rule_pos
);
22237 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22240 case RULE_OP_REJECT_NOT_CONTAIN
:
22241 NEXT_RULEPOS (rule_pos
);
22242 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22245 case RULE_OP_REJECT_EQUAL_FIRST
:
22246 NEXT_RULEPOS (rule_pos
);
22247 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22250 case RULE_OP_REJECT_EQUAL_LAST
:
22251 NEXT_RULEPOS (rule_pos
);
22252 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22255 case RULE_OP_REJECT_EQUAL_AT
:
22256 NEXT_RULEPOS (rule_pos
);
22257 NEXT_RPTOI (rule
, rule_pos
, upos
);
22258 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22259 NEXT_RULEPOS (rule_pos
);
22260 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22263 case RULE_OP_REJECT_CONTAINS
:
22264 NEXT_RULEPOS (rule_pos
);
22265 NEXT_RPTOI (rule
, rule_pos
, upos
);
22266 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22267 NEXT_RULEPOS (rule_pos
);
22268 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22269 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22272 case RULE_OP_REJECT_MEMORY
:
22273 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22277 return (RULE_RC_SYNTAX_ERROR
);
22282 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);