2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
117 int log_out_nn (FILE *fp
, const char *fmt
, ...)
119 if (SUPPRESS_OUTPUT
) return 0;
125 const int len
= log_final (fp
, fmt
, ap
);
132 int log_info_nn (const char *fmt
, ...)
134 if (SUPPRESS_OUTPUT
) return 0;
140 const int len
= log_final (stdout
, fmt
, ap
);
147 int log_error_nn (const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return 0;
155 const int len
= log_final (stderr
, fmt
, ap
);
162 int log_out (FILE *fp
, const char *fmt
, ...)
164 if (SUPPRESS_OUTPUT
) return 0;
170 const int len
= log_final (fp
, fmt
, ap
);
181 int log_info (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return 0;
189 const int len
= log_final (stdout
, fmt
, ap
);
193 fputc ('\n', stdout
);
200 int log_error (const char *fmt
, ...)
202 if (SUPPRESS_OUTPUT
) return 0;
204 fputc ('\n', stderr
);
205 fputc ('\n', stderr
);
211 const int len
= log_final (stderr
, fmt
, ap
);
215 fputc ('\n', stderr
);
216 fputc ('\n', stderr
);
227 u8
int_to_base32 (const u8 c
)
229 static const u8 tbl
[0x20] =
231 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
232 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
238 u8
base32_to_int (const u8 c
)
240 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
241 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
246 u8
int_to_itoa32 (const u8 c
)
248 static const u8 tbl
[0x20] =
250 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
251 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
257 u8
itoa32_to_int (const u8 c
)
259 if ((c
>= '0') && (c
<= '9')) return c
- '0';
260 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
265 u8
int_to_itoa64 (const u8 c
)
267 static const u8 tbl
[0x40] =
269 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
270 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
271 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
272 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
278 u8
itoa64_to_int (const u8 c
)
280 static const u8 tbl
[0x100] =
282 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
283 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
284 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
285 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
286 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
287 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
288 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
289 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
290 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
291 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
292 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
293 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
294 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
295 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
296 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
297 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
303 u8
int_to_base64 (const u8 c
)
305 static const u8 tbl
[0x40] =
307 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
308 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
309 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
310 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
316 u8
base64_to_int (const u8 c
)
318 static const u8 tbl
[0x100] =
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
323 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
327 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 u8
int_to_bf64 (const u8 c
)
343 static const u8 tbl
[0x40] =
345 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
346 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
347 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
348 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
354 u8
bf64_to_int (const u8 c
)
356 static const u8 tbl
[0x100] =
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
361 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
363 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
365 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 u8
int_to_lotus64 (const u8 c
)
381 if (c
< 10) return '0' + c
;
382 else if (c
< 36) return 'A' + c
- 10;
383 else if (c
< 62) return 'a' + c
- 36;
384 else if (c
== 62) return '+';
385 else if (c
== 63) return '/';
390 u8
lotus64_to_int (const u8 c
)
392 if ((c
>= '0') && (c
<= '9')) return c
- '0';
393 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
394 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
395 else if (c
== '+') return 62;
396 else if (c
== '/') return 63;
402 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
404 const u8
*in_ptr
= in_buf
;
406 u8
*out_ptr
= out_buf
;
408 for (int i
= 0; i
< in_len
; i
+= 8)
410 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
411 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
412 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
413 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
414 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
415 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
416 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
417 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
419 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
420 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
421 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
422 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
423 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
429 for (int i
= 0; i
< in_len
; i
++)
431 if (in_buf
[i
] != '=') continue;
436 int out_len
= (in_len
* 5) / 8;
441 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
443 const u8
*in_ptr
= in_buf
;
445 u8
*out_ptr
= out_buf
;
447 for (int i
= 0; i
< in_len
; i
+= 5)
449 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
450 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
451 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
452 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
453 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
454 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
455 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
456 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
458 out_ptr
[0] = out_val0
& 0x7f;
459 out_ptr
[1] = out_val1
& 0x7f;
460 out_ptr
[2] = out_val2
& 0x7f;
461 out_ptr
[3] = out_val3
& 0x7f;
462 out_ptr
[4] = out_val4
& 0x7f;
463 out_ptr
[5] = out_val5
& 0x7f;
464 out_ptr
[6] = out_val6
& 0x7f;
465 out_ptr
[7] = out_val7
& 0x7f;
471 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
475 out_buf
[out_len
] = '=';
483 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
485 const u8
*in_ptr
= in_buf
;
487 u8
*out_ptr
= out_buf
;
489 for (int i
= 0; i
< in_len
; i
+= 4)
491 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
492 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
493 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
494 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
496 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
497 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
498 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
504 for (int i
= 0; i
< in_len
; i
++)
506 if (in_buf
[i
] != '=') continue;
511 int out_len
= (in_len
* 6) / 8;
516 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
518 const u8
*in_ptr
= in_buf
;
520 u8
*out_ptr
= out_buf
;
522 for (int i
= 0; i
< in_len
; i
+= 3)
524 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
525 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
526 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
527 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
529 out_ptr
[0] = out_val0
& 0x7f;
530 out_ptr
[1] = out_val1
& 0x7f;
531 out_ptr
[2] = out_val2
& 0x7f;
532 out_ptr
[3] = out_val3
& 0x7f;
538 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
542 out_buf
[out_len
] = '=';
550 int is_valid_hex_char (const u8 c
)
552 if ((c
>= '0') && (c
<= '9')) return 1;
553 if ((c
>= 'A') && (c
<= 'F')) return 1;
554 if ((c
>= 'a') && (c
<= 'f')) return 1;
559 u8
hex_convert (const u8 c
)
561 return (c
& 15) + (c
>> 6) * 9;
564 u8
hex_to_u8 (const u8 hex
[2])
568 v
|= (hex_convert (hex
[1]) << 0);
569 v
|= (hex_convert (hex
[0]) << 4);
574 u32
hex_to_u32 (const u8 hex
[8])
578 v
|= ((u32
) hex_convert (hex
[7])) << 0;
579 v
|= ((u32
) hex_convert (hex
[6])) << 4;
580 v
|= ((u32
) hex_convert (hex
[5])) << 8;
581 v
|= ((u32
) hex_convert (hex
[4])) << 12;
582 v
|= ((u32
) hex_convert (hex
[3])) << 16;
583 v
|= ((u32
) hex_convert (hex
[2])) << 20;
584 v
|= ((u32
) hex_convert (hex
[1])) << 24;
585 v
|= ((u32
) hex_convert (hex
[0])) << 28;
590 u64
hex_to_u64 (const u8 hex
[16])
594 v
|= ((u64
) hex_convert (hex
[15]) << 0);
595 v
|= ((u64
) hex_convert (hex
[14]) << 4);
596 v
|= ((u64
) hex_convert (hex
[13]) << 8);
597 v
|= ((u64
) hex_convert (hex
[12]) << 12);
598 v
|= ((u64
) hex_convert (hex
[11]) << 16);
599 v
|= ((u64
) hex_convert (hex
[10]) << 20);
600 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
601 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
602 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
603 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
604 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
605 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
606 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
607 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
608 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
609 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
614 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
616 hex
[0] = v
>> 28 & 15;
617 hex
[1] = v
>> 24 & 15;
618 hex
[2] = v
>> 20 & 15;
619 hex
[3] = v
>> 16 & 15;
620 hex
[4] = v
>> 12 & 15;
621 hex
[5] = v
>> 8 & 15;
622 hex
[6] = v
>> 4 & 15;
623 hex
[7] = v
>> 0 & 15;
627 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
628 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
629 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
630 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
631 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
632 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
633 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
634 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
641 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
645 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
654 for (int i
= 0; i
< 16; i
+= 4)
664 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
671 out
[i
+ 0] = _out
[0];
672 out
[i
+ 1] = _out
[1];
673 out
[i
+ 2] = _out
[2];
674 out
[i
+ 3] = _out
[3];
683 static void juniper_decrypt_hash (char *in
, char *out
)
687 u8 base64_buf
[100] = { 0 };
689 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
693 u32 juniper_iv
[4] = { 0 };
695 memcpy (juniper_iv
, base64_buf
, 12);
697 memcpy (out
, juniper_iv
, 12);
701 u32 juniper_key
[4] = { 0 };
703 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
704 juniper_key
[1] = byte_swap_32 (0x8df91059);
705 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
706 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
710 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
711 u32
*out_ptr
= (u32
*) (out
+ 12);
713 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
716 void phpass_decode (u8 digest
[16], u8 buf
[22])
720 l
= itoa64_to_int (buf
[ 0]) << 0;
721 l
|= itoa64_to_int (buf
[ 1]) << 6;
722 l
|= itoa64_to_int (buf
[ 2]) << 12;
723 l
|= itoa64_to_int (buf
[ 3]) << 18;
725 digest
[ 0] = (l
>> 0) & 0xff;
726 digest
[ 1] = (l
>> 8) & 0xff;
727 digest
[ 2] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[ 4]) << 0;
730 l
|= itoa64_to_int (buf
[ 5]) << 6;
731 l
|= itoa64_to_int (buf
[ 6]) << 12;
732 l
|= itoa64_to_int (buf
[ 7]) << 18;
734 digest
[ 3] = (l
>> 0) & 0xff;
735 digest
[ 4] = (l
>> 8) & 0xff;
736 digest
[ 5] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[ 8]) << 0;
739 l
|= itoa64_to_int (buf
[ 9]) << 6;
740 l
|= itoa64_to_int (buf
[10]) << 12;
741 l
|= itoa64_to_int (buf
[11]) << 18;
743 digest
[ 6] = (l
>> 0) & 0xff;
744 digest
[ 7] = (l
>> 8) & 0xff;
745 digest
[ 8] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[12]) << 0;
748 l
|= itoa64_to_int (buf
[13]) << 6;
749 l
|= itoa64_to_int (buf
[14]) << 12;
750 l
|= itoa64_to_int (buf
[15]) << 18;
752 digest
[ 9] = (l
>> 0) & 0xff;
753 digest
[10] = (l
>> 8) & 0xff;
754 digest
[11] = (l
>> 16) & 0xff;
756 l
= itoa64_to_int (buf
[16]) << 0;
757 l
|= itoa64_to_int (buf
[17]) << 6;
758 l
|= itoa64_to_int (buf
[18]) << 12;
759 l
|= itoa64_to_int (buf
[19]) << 18;
761 digest
[12] = (l
>> 0) & 0xff;
762 digest
[13] = (l
>> 8) & 0xff;
763 digest
[14] = (l
>> 16) & 0xff;
765 l
= itoa64_to_int (buf
[20]) << 0;
766 l
|= itoa64_to_int (buf
[21]) << 6;
768 digest
[15] = (l
>> 0) & 0xff;
771 void phpass_encode (u8 digest
[16], u8 buf
[22])
775 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
777 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
784 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
791 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[11] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
798 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
800 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[15] = int_to_itoa64 (l
& 0x3f);
803 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
805 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
807 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
808 buf
[19] = int_to_itoa64 (l
& 0x3f);
810 l
= (digest
[15] << 0);
812 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[21] = int_to_itoa64 (l
& 0x3f);
816 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
820 l
= itoa64_to_int (buf
[ 0]) << 0;
821 l
|= itoa64_to_int (buf
[ 1]) << 6;
822 l
|= itoa64_to_int (buf
[ 2]) << 12;
823 l
|= itoa64_to_int (buf
[ 3]) << 18;
825 digest
[ 0] = (l
>> 16) & 0xff;
826 digest
[ 6] = (l
>> 8) & 0xff;
827 digest
[12] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[ 4]) << 0;
830 l
|= itoa64_to_int (buf
[ 5]) << 6;
831 l
|= itoa64_to_int (buf
[ 6]) << 12;
832 l
|= itoa64_to_int (buf
[ 7]) << 18;
834 digest
[ 1] = (l
>> 16) & 0xff;
835 digest
[ 7] = (l
>> 8) & 0xff;
836 digest
[13] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[ 8]) << 0;
839 l
|= itoa64_to_int (buf
[ 9]) << 6;
840 l
|= itoa64_to_int (buf
[10]) << 12;
841 l
|= itoa64_to_int (buf
[11]) << 18;
843 digest
[ 2] = (l
>> 16) & 0xff;
844 digest
[ 8] = (l
>> 8) & 0xff;
845 digest
[14] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[12]) << 0;
848 l
|= itoa64_to_int (buf
[13]) << 6;
849 l
|= itoa64_to_int (buf
[14]) << 12;
850 l
|= itoa64_to_int (buf
[15]) << 18;
852 digest
[ 3] = (l
>> 16) & 0xff;
853 digest
[ 9] = (l
>> 8) & 0xff;
854 digest
[15] = (l
>> 0) & 0xff;
856 l
= itoa64_to_int (buf
[16]) << 0;
857 l
|= itoa64_to_int (buf
[17]) << 6;
858 l
|= itoa64_to_int (buf
[18]) << 12;
859 l
|= itoa64_to_int (buf
[19]) << 18;
861 digest
[ 4] = (l
>> 16) & 0xff;
862 digest
[10] = (l
>> 8) & 0xff;
863 digest
[ 5] = (l
>> 0) & 0xff;
865 l
= itoa64_to_int (buf
[20]) << 0;
866 l
|= itoa64_to_int (buf
[21]) << 6;
868 digest
[11] = (l
>> 0) & 0xff;
871 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
875 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
877 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
884 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
891 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
898 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
900 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
903 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
905 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
907 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
910 l
= (digest
[11] << 0);
912 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
916 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
920 l
= itoa64_to_int (buf
[ 0]) << 0;
921 l
|= itoa64_to_int (buf
[ 1]) << 6;
922 l
|= itoa64_to_int (buf
[ 2]) << 12;
923 l
|= itoa64_to_int (buf
[ 3]) << 18;
925 digest
[ 0] = (l
>> 16) & 0xff;
926 digest
[21] = (l
>> 8) & 0xff;
927 digest
[42] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[ 4]) << 0;
930 l
|= itoa64_to_int (buf
[ 5]) << 6;
931 l
|= itoa64_to_int (buf
[ 6]) << 12;
932 l
|= itoa64_to_int (buf
[ 7]) << 18;
934 digest
[22] = (l
>> 16) & 0xff;
935 digest
[43] = (l
>> 8) & 0xff;
936 digest
[ 1] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[ 8]) << 0;
939 l
|= itoa64_to_int (buf
[ 9]) << 6;
940 l
|= itoa64_to_int (buf
[10]) << 12;
941 l
|= itoa64_to_int (buf
[11]) << 18;
943 digest
[44] = (l
>> 16) & 0xff;
944 digest
[ 2] = (l
>> 8) & 0xff;
945 digest
[23] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[12]) << 0;
948 l
|= itoa64_to_int (buf
[13]) << 6;
949 l
|= itoa64_to_int (buf
[14]) << 12;
950 l
|= itoa64_to_int (buf
[15]) << 18;
952 digest
[ 3] = (l
>> 16) & 0xff;
953 digest
[24] = (l
>> 8) & 0xff;
954 digest
[45] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[16]) << 0;
957 l
|= itoa64_to_int (buf
[17]) << 6;
958 l
|= itoa64_to_int (buf
[18]) << 12;
959 l
|= itoa64_to_int (buf
[19]) << 18;
961 digest
[25] = (l
>> 16) & 0xff;
962 digest
[46] = (l
>> 8) & 0xff;
963 digest
[ 4] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[20]) << 0;
966 l
|= itoa64_to_int (buf
[21]) << 6;
967 l
|= itoa64_to_int (buf
[22]) << 12;
968 l
|= itoa64_to_int (buf
[23]) << 18;
970 digest
[47] = (l
>> 16) & 0xff;
971 digest
[ 5] = (l
>> 8) & 0xff;
972 digest
[26] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[24]) << 0;
975 l
|= itoa64_to_int (buf
[25]) << 6;
976 l
|= itoa64_to_int (buf
[26]) << 12;
977 l
|= itoa64_to_int (buf
[27]) << 18;
979 digest
[ 6] = (l
>> 16) & 0xff;
980 digest
[27] = (l
>> 8) & 0xff;
981 digest
[48] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[28]) << 0;
984 l
|= itoa64_to_int (buf
[29]) << 6;
985 l
|= itoa64_to_int (buf
[30]) << 12;
986 l
|= itoa64_to_int (buf
[31]) << 18;
988 digest
[28] = (l
>> 16) & 0xff;
989 digest
[49] = (l
>> 8) & 0xff;
990 digest
[ 7] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[32]) << 0;
993 l
|= itoa64_to_int (buf
[33]) << 6;
994 l
|= itoa64_to_int (buf
[34]) << 12;
995 l
|= itoa64_to_int (buf
[35]) << 18;
997 digest
[50] = (l
>> 16) & 0xff;
998 digest
[ 8] = (l
>> 8) & 0xff;
999 digest
[29] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[36]) << 0;
1002 l
|= itoa64_to_int (buf
[37]) << 6;
1003 l
|= itoa64_to_int (buf
[38]) << 12;
1004 l
|= itoa64_to_int (buf
[39]) << 18;
1006 digest
[ 9] = (l
>> 16) & 0xff;
1007 digest
[30] = (l
>> 8) & 0xff;
1008 digest
[51] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[40]) << 0;
1011 l
|= itoa64_to_int (buf
[41]) << 6;
1012 l
|= itoa64_to_int (buf
[42]) << 12;
1013 l
|= itoa64_to_int (buf
[43]) << 18;
1015 digest
[31] = (l
>> 16) & 0xff;
1016 digest
[52] = (l
>> 8) & 0xff;
1017 digest
[10] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[44]) << 0;
1020 l
|= itoa64_to_int (buf
[45]) << 6;
1021 l
|= itoa64_to_int (buf
[46]) << 12;
1022 l
|= itoa64_to_int (buf
[47]) << 18;
1024 digest
[53] = (l
>> 16) & 0xff;
1025 digest
[11] = (l
>> 8) & 0xff;
1026 digest
[32] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[48]) << 0;
1029 l
|= itoa64_to_int (buf
[49]) << 6;
1030 l
|= itoa64_to_int (buf
[50]) << 12;
1031 l
|= itoa64_to_int (buf
[51]) << 18;
1033 digest
[12] = (l
>> 16) & 0xff;
1034 digest
[33] = (l
>> 8) & 0xff;
1035 digest
[54] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[52]) << 0;
1038 l
|= itoa64_to_int (buf
[53]) << 6;
1039 l
|= itoa64_to_int (buf
[54]) << 12;
1040 l
|= itoa64_to_int (buf
[55]) << 18;
1042 digest
[34] = (l
>> 16) & 0xff;
1043 digest
[55] = (l
>> 8) & 0xff;
1044 digest
[13] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[56]) << 0;
1047 l
|= itoa64_to_int (buf
[57]) << 6;
1048 l
|= itoa64_to_int (buf
[58]) << 12;
1049 l
|= itoa64_to_int (buf
[59]) << 18;
1051 digest
[56] = (l
>> 16) & 0xff;
1052 digest
[14] = (l
>> 8) & 0xff;
1053 digest
[35] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[60]) << 0;
1056 l
|= itoa64_to_int (buf
[61]) << 6;
1057 l
|= itoa64_to_int (buf
[62]) << 12;
1058 l
|= itoa64_to_int (buf
[63]) << 18;
1060 digest
[15] = (l
>> 16) & 0xff;
1061 digest
[36] = (l
>> 8) & 0xff;
1062 digest
[57] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[64]) << 0;
1065 l
|= itoa64_to_int (buf
[65]) << 6;
1066 l
|= itoa64_to_int (buf
[66]) << 12;
1067 l
|= itoa64_to_int (buf
[67]) << 18;
1069 digest
[37] = (l
>> 16) & 0xff;
1070 digest
[58] = (l
>> 8) & 0xff;
1071 digest
[16] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[68]) << 0;
1074 l
|= itoa64_to_int (buf
[69]) << 6;
1075 l
|= itoa64_to_int (buf
[70]) << 12;
1076 l
|= itoa64_to_int (buf
[71]) << 18;
1078 digest
[59] = (l
>> 16) & 0xff;
1079 digest
[17] = (l
>> 8) & 0xff;
1080 digest
[38] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[72]) << 0;
1083 l
|= itoa64_to_int (buf
[73]) << 6;
1084 l
|= itoa64_to_int (buf
[74]) << 12;
1085 l
|= itoa64_to_int (buf
[75]) << 18;
1087 digest
[18] = (l
>> 16) & 0xff;
1088 digest
[39] = (l
>> 8) & 0xff;
1089 digest
[60] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[76]) << 0;
1092 l
|= itoa64_to_int (buf
[77]) << 6;
1093 l
|= itoa64_to_int (buf
[78]) << 12;
1094 l
|= itoa64_to_int (buf
[79]) << 18;
1096 digest
[40] = (l
>> 16) & 0xff;
1097 digest
[61] = (l
>> 8) & 0xff;
1098 digest
[19] = (l
>> 0) & 0xff;
1100 l
= itoa64_to_int (buf
[80]) << 0;
1101 l
|= itoa64_to_int (buf
[81]) << 6;
1102 l
|= itoa64_to_int (buf
[82]) << 12;
1103 l
|= itoa64_to_int (buf
[83]) << 18;
1105 digest
[62] = (l
>> 16) & 0xff;
1106 digest
[20] = (l
>> 8) & 0xff;
1107 digest
[41] = (l
>> 0) & 0xff;
1109 l
= itoa64_to_int (buf
[84]) << 0;
1110 l
|= itoa64_to_int (buf
[85]) << 6;
1112 digest
[63] = (l
>> 0) & 0xff;
1115 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1119 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1121 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1128 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1135 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1142 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1149 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1156 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1163 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1170 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1177 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1184 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1191 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1198 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1205 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1212 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1219 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1226 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1233 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1240 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1247 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1254 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1256 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1259 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1261 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1263 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1266 l
= 0 | 0 | (digest
[63] << 0);
1268 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1272 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1276 l
= itoa64_to_int (buf
[ 0]) << 0;
1277 l
|= itoa64_to_int (buf
[ 1]) << 6;
1278 l
|= itoa64_to_int (buf
[ 2]) << 12;
1279 l
|= itoa64_to_int (buf
[ 3]) << 18;
1281 digest
[ 2] = (l
>> 0) & 0xff;
1282 digest
[ 1] = (l
>> 8) & 0xff;
1283 digest
[ 0] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[ 4]) << 0;
1286 l
|= itoa64_to_int (buf
[ 5]) << 6;
1287 l
|= itoa64_to_int (buf
[ 6]) << 12;
1288 l
|= itoa64_to_int (buf
[ 7]) << 18;
1290 digest
[ 5] = (l
>> 0) & 0xff;
1291 digest
[ 4] = (l
>> 8) & 0xff;
1292 digest
[ 3] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[ 8]) << 0;
1295 l
|= itoa64_to_int (buf
[ 9]) << 6;
1296 l
|= itoa64_to_int (buf
[10]) << 12;
1297 l
|= itoa64_to_int (buf
[11]) << 18;
1299 digest
[ 8] = (l
>> 0) & 0xff;
1300 digest
[ 7] = (l
>> 8) & 0xff;
1301 digest
[ 6] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[12]) << 0;
1304 l
|= itoa64_to_int (buf
[13]) << 6;
1305 l
|= itoa64_to_int (buf
[14]) << 12;
1306 l
|= itoa64_to_int (buf
[15]) << 18;
1308 digest
[11] = (l
>> 0) & 0xff;
1309 digest
[10] = (l
>> 8) & 0xff;
1310 digest
[ 9] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[16]) << 0;
1313 l
|= itoa64_to_int (buf
[17]) << 6;
1314 l
|= itoa64_to_int (buf
[18]) << 12;
1315 l
|= itoa64_to_int (buf
[19]) << 18;
1317 digest
[14] = (l
>> 0) & 0xff;
1318 digest
[13] = (l
>> 8) & 0xff;
1319 digest
[12] = (l
>> 16) & 0xff;
1321 l
= itoa64_to_int (buf
[20]) << 0;
1322 l
|= itoa64_to_int (buf
[21]) << 6;
1323 l
|= itoa64_to_int (buf
[22]) << 12;
1324 l
|= itoa64_to_int (buf
[23]) << 18;
1326 digest
[17] = (l
>> 0) & 0xff;
1327 digest
[16] = (l
>> 8) & 0xff;
1328 digest
[15] = (l
>> 16) & 0xff;
1330 l
= itoa64_to_int (buf
[24]) << 0;
1331 l
|= itoa64_to_int (buf
[25]) << 6;
1332 l
|= itoa64_to_int (buf
[26]) << 12;
1334 digest
[19] = (l
>> 8) & 0xff;
1335 digest
[18] = (l
>> 16) & 0xff;
1338 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1342 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1344 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1351 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1358 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[11] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1365 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[15] = int_to_itoa64 (l
& 0x3f);
1370 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1372 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[19] = int_to_itoa64 (l
& 0x3f);
1377 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1379 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1381 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1382 buf
[23] = int_to_itoa64 (l
& 0x3f);
1384 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1386 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1388 buf
[26] = int_to_itoa64 (l
& 0x3f);
1391 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1395 l
= itoa64_to_int (buf
[ 0]) << 0;
1396 l
|= itoa64_to_int (buf
[ 1]) << 6;
1397 l
|= itoa64_to_int (buf
[ 2]) << 12;
1398 l
|= itoa64_to_int (buf
[ 3]) << 18;
1400 digest
[ 2] = (l
>> 0) & 0xff;
1401 digest
[ 1] = (l
>> 8) & 0xff;
1402 digest
[ 0] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[ 4]) << 0;
1405 l
|= itoa64_to_int (buf
[ 5]) << 6;
1406 l
|= itoa64_to_int (buf
[ 6]) << 12;
1407 l
|= itoa64_to_int (buf
[ 7]) << 18;
1409 digest
[ 5] = (l
>> 0) & 0xff;
1410 digest
[ 4] = (l
>> 8) & 0xff;
1411 digest
[ 3] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[ 8]) << 0;
1414 l
|= itoa64_to_int (buf
[ 9]) << 6;
1415 l
|= itoa64_to_int (buf
[10]) << 12;
1416 l
|= itoa64_to_int (buf
[11]) << 18;
1418 digest
[ 8] = (l
>> 0) & 0xff;
1419 digest
[ 7] = (l
>> 8) & 0xff;
1420 digest
[ 6] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[12]) << 0;
1423 l
|= itoa64_to_int (buf
[13]) << 6;
1424 l
|= itoa64_to_int (buf
[14]) << 12;
1425 l
|= itoa64_to_int (buf
[15]) << 18;
1427 digest
[11] = (l
>> 0) & 0xff;
1428 digest
[10] = (l
>> 8) & 0xff;
1429 digest
[ 9] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[16]) << 0;
1432 l
|= itoa64_to_int (buf
[17]) << 6;
1433 l
|= itoa64_to_int (buf
[18]) << 12;
1434 l
|= itoa64_to_int (buf
[19]) << 18;
1436 digest
[14] = (l
>> 0) & 0xff;
1437 digest
[13] = (l
>> 8) & 0xff;
1438 digest
[12] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[20]) << 0;
1441 l
|= itoa64_to_int (buf
[21]) << 6;
1442 l
|= itoa64_to_int (buf
[22]) << 12;
1443 l
|= itoa64_to_int (buf
[23]) << 18;
1445 digest
[17] = (l
>> 0) & 0xff;
1446 digest
[16] = (l
>> 8) & 0xff;
1447 digest
[15] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[24]) << 0;
1450 l
|= itoa64_to_int (buf
[25]) << 6;
1451 l
|= itoa64_to_int (buf
[26]) << 12;
1452 l
|= itoa64_to_int (buf
[27]) << 18;
1454 digest
[20] = (l
>> 0) & 0xff;
1455 digest
[19] = (l
>> 8) & 0xff;
1456 digest
[18] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[28]) << 0;
1459 l
|= itoa64_to_int (buf
[29]) << 6;
1460 l
|= itoa64_to_int (buf
[30]) << 12;
1461 l
|= itoa64_to_int (buf
[31]) << 18;
1463 digest
[23] = (l
>> 0) & 0xff;
1464 digest
[22] = (l
>> 8) & 0xff;
1465 digest
[21] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[32]) << 0;
1468 l
|= itoa64_to_int (buf
[33]) << 6;
1469 l
|= itoa64_to_int (buf
[34]) << 12;
1470 l
|= itoa64_to_int (buf
[35]) << 18;
1472 digest
[26] = (l
>> 0) & 0xff;
1473 digest
[25] = (l
>> 8) & 0xff;
1474 digest
[24] = (l
>> 16) & 0xff;
1476 l
= itoa64_to_int (buf
[36]) << 0;
1477 l
|= itoa64_to_int (buf
[37]) << 6;
1478 l
|= itoa64_to_int (buf
[38]) << 12;
1479 l
|= itoa64_to_int (buf
[39]) << 18;
1481 digest
[29] = (l
>> 0) & 0xff;
1482 digest
[28] = (l
>> 8) & 0xff;
1483 digest
[27] = (l
>> 16) & 0xff;
1485 l
= itoa64_to_int (buf
[40]) << 0;
1486 l
|= itoa64_to_int (buf
[41]) << 6;
1487 l
|= itoa64_to_int (buf
[42]) << 12;
1489 //digest[32] = (l >> 0) & 0xff;
1490 digest
[31] = (l
>> 8) & 0xff;
1491 digest
[30] = (l
>> 16) & 0xff;
1494 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1498 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1500 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1507 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1514 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[11] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1521 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[15] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1528 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[19] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1535 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[23] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1542 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[27] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1549 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[31] = int_to_itoa64 (l
& 0x3f);
1554 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1556 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[35] = int_to_itoa64 (l
& 0x3f);
1561 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1563 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1565 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1566 buf
[39] = int_to_itoa64 (l
& 0x3f);
1568 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1570 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1572 buf
[42] = int_to_itoa64 (l
& 0x3f);
1575 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1579 l
= itoa64_to_int (buf
[ 0]) << 0;
1580 l
|= itoa64_to_int (buf
[ 1]) << 6;
1581 l
|= itoa64_to_int (buf
[ 2]) << 12;
1582 l
|= itoa64_to_int (buf
[ 3]) << 18;
1584 digest
[ 2] = (l
>> 0) & 0xff;
1585 digest
[ 1] = (l
>> 8) & 0xff;
1586 digest
[ 0] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[ 4]) << 0;
1589 l
|= itoa64_to_int (buf
[ 5]) << 6;
1590 l
|= itoa64_to_int (buf
[ 6]) << 12;
1591 l
|= itoa64_to_int (buf
[ 7]) << 18;
1593 digest
[ 5] = (l
>> 0) & 0xff;
1594 digest
[ 4] = (l
>> 8) & 0xff;
1595 digest
[ 3] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[ 8]) << 0;
1598 l
|= itoa64_to_int (buf
[ 9]) << 6;
1599 l
|= itoa64_to_int (buf
[10]) << 12;
1600 l
|= itoa64_to_int (buf
[11]) << 18;
1602 digest
[ 8] = (l
>> 0) & 0xff;
1603 digest
[ 7] = (l
>> 8) & 0xff;
1604 digest
[ 6] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[12]) << 0;
1607 l
|= itoa64_to_int (buf
[13]) << 6;
1608 l
|= itoa64_to_int (buf
[14]) << 12;
1609 l
|= itoa64_to_int (buf
[15]) << 18;
1611 digest
[11] = (l
>> 0) & 0xff;
1612 digest
[10] = (l
>> 8) & 0xff;
1613 digest
[ 9] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[16]) << 0;
1616 l
|= itoa64_to_int (buf
[17]) << 6;
1617 l
|= itoa64_to_int (buf
[18]) << 12;
1618 l
|= itoa64_to_int (buf
[19]) << 18;
1620 digest
[14] = (l
>> 0) & 0xff;
1621 digest
[13] = (l
>> 8) & 0xff;
1622 digest
[12] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[20]) << 0;
1625 l
|= itoa64_to_int (buf
[21]) << 6;
1626 l
|= itoa64_to_int (buf
[22]) << 12;
1627 l
|= itoa64_to_int (buf
[23]) << 18;
1629 digest
[17] = (l
>> 0) & 0xff;
1630 digest
[16] = (l
>> 8) & 0xff;
1631 digest
[15] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[24]) << 0;
1634 l
|= itoa64_to_int (buf
[25]) << 6;
1635 l
|= itoa64_to_int (buf
[26]) << 12;
1636 l
|= itoa64_to_int (buf
[27]) << 18;
1638 digest
[20] = (l
>> 0) & 0xff;
1639 digest
[19] = (l
>> 8) & 0xff;
1640 digest
[18] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[28]) << 0;
1643 l
|= itoa64_to_int (buf
[29]) << 6;
1644 l
|= itoa64_to_int (buf
[30]) << 12;
1645 l
|= itoa64_to_int (buf
[31]) << 18;
1647 digest
[23] = (l
>> 0) & 0xff;
1648 digest
[22] = (l
>> 8) & 0xff;
1649 digest
[21] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[32]) << 0;
1652 l
|= itoa64_to_int (buf
[33]) << 6;
1653 l
|= itoa64_to_int (buf
[34]) << 12;
1654 l
|= itoa64_to_int (buf
[35]) << 18;
1656 digest
[26] = (l
>> 0) & 0xff;
1657 digest
[25] = (l
>> 8) & 0xff;
1658 digest
[24] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[36]) << 0;
1661 l
|= itoa64_to_int (buf
[37]) << 6;
1662 l
|= itoa64_to_int (buf
[38]) << 12;
1663 l
|= itoa64_to_int (buf
[39]) << 18;
1665 digest
[29] = (l
>> 0) & 0xff;
1666 digest
[28] = (l
>> 8) & 0xff;
1667 digest
[27] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[40]) << 0;
1670 l
|= itoa64_to_int (buf
[41]) << 6;
1671 l
|= itoa64_to_int (buf
[42]) << 12;
1672 l
|= itoa64_to_int (buf
[43]) << 18;
1674 digest
[32] = (l
>> 0) & 0xff;
1675 digest
[31] = (l
>> 8) & 0xff;
1676 digest
[30] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[44]) << 0;
1679 l
|= itoa64_to_int (buf
[45]) << 6;
1680 l
|= itoa64_to_int (buf
[46]) << 12;
1681 l
|= itoa64_to_int (buf
[47]) << 18;
1683 digest
[35] = (l
>> 0) & 0xff;
1684 digest
[34] = (l
>> 8) & 0xff;
1685 digest
[33] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[48]) << 0;
1688 l
|= itoa64_to_int (buf
[49]) << 6;
1689 l
|= itoa64_to_int (buf
[50]) << 12;
1690 l
|= itoa64_to_int (buf
[51]) << 18;
1692 digest
[38] = (l
>> 0) & 0xff;
1693 digest
[37] = (l
>> 8) & 0xff;
1694 digest
[36] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[52]) << 0;
1697 l
|= itoa64_to_int (buf
[53]) << 6;
1698 l
|= itoa64_to_int (buf
[54]) << 12;
1699 l
|= itoa64_to_int (buf
[55]) << 18;
1701 digest
[41] = (l
>> 0) & 0xff;
1702 digest
[40] = (l
>> 8) & 0xff;
1703 digest
[39] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[56]) << 0;
1706 l
|= itoa64_to_int (buf
[57]) << 6;
1707 l
|= itoa64_to_int (buf
[58]) << 12;
1708 l
|= itoa64_to_int (buf
[59]) << 18;
1710 digest
[44] = (l
>> 0) & 0xff;
1711 digest
[43] = (l
>> 8) & 0xff;
1712 digest
[42] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[60]) << 0;
1715 l
|= itoa64_to_int (buf
[61]) << 6;
1716 l
|= itoa64_to_int (buf
[62]) << 12;
1717 l
|= itoa64_to_int (buf
[63]) << 18;
1719 digest
[47] = (l
>> 0) & 0xff;
1720 digest
[46] = (l
>> 8) & 0xff;
1721 digest
[45] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[64]) << 0;
1724 l
|= itoa64_to_int (buf
[65]) << 6;
1725 l
|= itoa64_to_int (buf
[66]) << 12;
1726 l
|= itoa64_to_int (buf
[67]) << 18;
1728 digest
[50] = (l
>> 0) & 0xff;
1729 digest
[49] = (l
>> 8) & 0xff;
1730 digest
[48] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[68]) << 0;
1733 l
|= itoa64_to_int (buf
[69]) << 6;
1734 l
|= itoa64_to_int (buf
[70]) << 12;
1735 l
|= itoa64_to_int (buf
[71]) << 18;
1737 digest
[53] = (l
>> 0) & 0xff;
1738 digest
[52] = (l
>> 8) & 0xff;
1739 digest
[51] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[72]) << 0;
1742 l
|= itoa64_to_int (buf
[73]) << 6;
1743 l
|= itoa64_to_int (buf
[74]) << 12;
1744 l
|= itoa64_to_int (buf
[75]) << 18;
1746 digest
[56] = (l
>> 0) & 0xff;
1747 digest
[55] = (l
>> 8) & 0xff;
1748 digest
[54] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[76]) << 0;
1751 l
|= itoa64_to_int (buf
[77]) << 6;
1752 l
|= itoa64_to_int (buf
[78]) << 12;
1753 l
|= itoa64_to_int (buf
[79]) << 18;
1755 digest
[59] = (l
>> 0) & 0xff;
1756 digest
[58] = (l
>> 8) & 0xff;
1757 digest
[57] = (l
>> 16) & 0xff;
1759 l
= itoa64_to_int (buf
[80]) << 0;
1760 l
|= itoa64_to_int (buf
[81]) << 6;
1761 l
|= itoa64_to_int (buf
[82]) << 12;
1762 l
|= itoa64_to_int (buf
[83]) << 18;
1764 digest
[62] = (l
>> 0) & 0xff;
1765 digest
[61] = (l
>> 8) & 0xff;
1766 digest
[60] = (l
>> 16) & 0xff;
1768 l
= itoa64_to_int (buf
[84]) << 0;
1769 l
|= itoa64_to_int (buf
[85]) << 6;
1771 digest
[63] = (l
>> 16) & 0xff;
1774 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1778 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1780 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1787 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1794 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[11] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1801 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[15] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1808 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[19] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1815 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[23] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1822 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[27] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1829 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[31] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1836 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[35] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1843 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[39] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1850 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[43] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1857 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[47] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1864 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[51] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1871 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[55] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1878 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[59] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1885 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[63] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1892 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[67] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1899 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[71] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1906 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[75] = int_to_itoa64 (l
& 0x3f);
1911 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1913 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1915 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[79] = int_to_itoa64 (l
& 0x3f);
1918 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1920 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1922 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1923 buf
[83] = int_to_itoa64 (l
& 0x3f);
1925 l
= 0 | 0 | (digest
[63] << 16);
1927 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1931 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1935 l
= itoa64_to_int (buf
[ 0]) << 0;
1936 l
|= itoa64_to_int (buf
[ 1]) << 6;
1937 l
|= itoa64_to_int (buf
[ 2]) << 12;
1938 l
|= itoa64_to_int (buf
[ 3]) << 18;
1940 digest
[ 0] = (l
>> 16) & 0xff;
1941 digest
[10] = (l
>> 8) & 0xff;
1942 digest
[20] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[ 4]) << 0;
1945 l
|= itoa64_to_int (buf
[ 5]) << 6;
1946 l
|= itoa64_to_int (buf
[ 6]) << 12;
1947 l
|= itoa64_to_int (buf
[ 7]) << 18;
1949 digest
[21] = (l
>> 16) & 0xff;
1950 digest
[ 1] = (l
>> 8) & 0xff;
1951 digest
[11] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[ 8]) << 0;
1954 l
|= itoa64_to_int (buf
[ 9]) << 6;
1955 l
|= itoa64_to_int (buf
[10]) << 12;
1956 l
|= itoa64_to_int (buf
[11]) << 18;
1958 digest
[12] = (l
>> 16) & 0xff;
1959 digest
[22] = (l
>> 8) & 0xff;
1960 digest
[ 2] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[12]) << 0;
1963 l
|= itoa64_to_int (buf
[13]) << 6;
1964 l
|= itoa64_to_int (buf
[14]) << 12;
1965 l
|= itoa64_to_int (buf
[15]) << 18;
1967 digest
[ 3] = (l
>> 16) & 0xff;
1968 digest
[13] = (l
>> 8) & 0xff;
1969 digest
[23] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[16]) << 0;
1972 l
|= itoa64_to_int (buf
[17]) << 6;
1973 l
|= itoa64_to_int (buf
[18]) << 12;
1974 l
|= itoa64_to_int (buf
[19]) << 18;
1976 digest
[24] = (l
>> 16) & 0xff;
1977 digest
[ 4] = (l
>> 8) & 0xff;
1978 digest
[14] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[20]) << 0;
1981 l
|= itoa64_to_int (buf
[21]) << 6;
1982 l
|= itoa64_to_int (buf
[22]) << 12;
1983 l
|= itoa64_to_int (buf
[23]) << 18;
1985 digest
[15] = (l
>> 16) & 0xff;
1986 digest
[25] = (l
>> 8) & 0xff;
1987 digest
[ 5] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[24]) << 0;
1990 l
|= itoa64_to_int (buf
[25]) << 6;
1991 l
|= itoa64_to_int (buf
[26]) << 12;
1992 l
|= itoa64_to_int (buf
[27]) << 18;
1994 digest
[ 6] = (l
>> 16) & 0xff;
1995 digest
[16] = (l
>> 8) & 0xff;
1996 digest
[26] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[28]) << 0;
1999 l
|= itoa64_to_int (buf
[29]) << 6;
2000 l
|= itoa64_to_int (buf
[30]) << 12;
2001 l
|= itoa64_to_int (buf
[31]) << 18;
2003 digest
[27] = (l
>> 16) & 0xff;
2004 digest
[ 7] = (l
>> 8) & 0xff;
2005 digest
[17] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[32]) << 0;
2008 l
|= itoa64_to_int (buf
[33]) << 6;
2009 l
|= itoa64_to_int (buf
[34]) << 12;
2010 l
|= itoa64_to_int (buf
[35]) << 18;
2012 digest
[18] = (l
>> 16) & 0xff;
2013 digest
[28] = (l
>> 8) & 0xff;
2014 digest
[ 8] = (l
>> 0) & 0xff;
2016 l
= itoa64_to_int (buf
[36]) << 0;
2017 l
|= itoa64_to_int (buf
[37]) << 6;
2018 l
|= itoa64_to_int (buf
[38]) << 12;
2019 l
|= itoa64_to_int (buf
[39]) << 18;
2021 digest
[ 9] = (l
>> 16) & 0xff;
2022 digest
[19] = (l
>> 8) & 0xff;
2023 digest
[29] = (l
>> 0) & 0xff;
2025 l
= itoa64_to_int (buf
[40]) << 0;
2026 l
|= itoa64_to_int (buf
[41]) << 6;
2027 l
|= itoa64_to_int (buf
[42]) << 12;
2029 digest
[31] = (l
>> 8) & 0xff;
2030 digest
[30] = (l
>> 0) & 0xff;
2033 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2037 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2039 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2046 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2053 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2060 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2067 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2074 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2081 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2088 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2095 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2102 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2104 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2107 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2109 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2111 buf
[42] = int_to_itoa64 (l
& 0x3f);
2114 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2118 l
= itoa64_to_int (buf
[ 0]) << 0;
2119 l
|= itoa64_to_int (buf
[ 1]) << 6;
2120 l
|= itoa64_to_int (buf
[ 2]) << 12;
2121 l
|= itoa64_to_int (buf
[ 3]) << 18;
2123 digest
[ 0] = (l
>> 0) & 0xff;
2124 digest
[ 1] = (l
>> 8) & 0xff;
2125 digest
[ 2] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[ 4]) << 0;
2128 l
|= itoa64_to_int (buf
[ 5]) << 6;
2129 l
|= itoa64_to_int (buf
[ 6]) << 12;
2130 l
|= itoa64_to_int (buf
[ 7]) << 18;
2132 digest
[ 3] = (l
>> 0) & 0xff;
2133 digest
[ 4] = (l
>> 8) & 0xff;
2134 digest
[ 5] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[ 8]) << 0;
2137 l
|= itoa64_to_int (buf
[ 9]) << 6;
2138 l
|= itoa64_to_int (buf
[10]) << 12;
2139 l
|= itoa64_to_int (buf
[11]) << 18;
2141 digest
[ 6] = (l
>> 0) & 0xff;
2142 digest
[ 7] = (l
>> 8) & 0xff;
2143 digest
[ 8] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[12]) << 0;
2146 l
|= itoa64_to_int (buf
[13]) << 6;
2147 l
|= itoa64_to_int (buf
[14]) << 12;
2148 l
|= itoa64_to_int (buf
[15]) << 18;
2150 digest
[ 9] = (l
>> 0) & 0xff;
2151 digest
[10] = (l
>> 8) & 0xff;
2152 digest
[11] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[16]) << 0;
2155 l
|= itoa64_to_int (buf
[17]) << 6;
2156 l
|= itoa64_to_int (buf
[18]) << 12;
2157 l
|= itoa64_to_int (buf
[19]) << 18;
2159 digest
[12] = (l
>> 0) & 0xff;
2160 digest
[13] = (l
>> 8) & 0xff;
2161 digest
[14] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[20]) << 0;
2164 l
|= itoa64_to_int (buf
[21]) << 6;
2165 l
|= itoa64_to_int (buf
[22]) << 12;
2166 l
|= itoa64_to_int (buf
[23]) << 18;
2168 digest
[15] = (l
>> 0) & 0xff;
2169 digest
[16] = (l
>> 8) & 0xff;
2170 digest
[17] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[24]) << 0;
2173 l
|= itoa64_to_int (buf
[25]) << 6;
2174 l
|= itoa64_to_int (buf
[26]) << 12;
2175 l
|= itoa64_to_int (buf
[27]) << 18;
2177 digest
[18] = (l
>> 0) & 0xff;
2178 digest
[19] = (l
>> 8) & 0xff;
2179 digest
[20] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[28]) << 0;
2182 l
|= itoa64_to_int (buf
[29]) << 6;
2183 l
|= itoa64_to_int (buf
[30]) << 12;
2184 l
|= itoa64_to_int (buf
[31]) << 18;
2186 digest
[21] = (l
>> 0) & 0xff;
2187 digest
[22] = (l
>> 8) & 0xff;
2188 digest
[23] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[32]) << 0;
2191 l
|= itoa64_to_int (buf
[33]) << 6;
2192 l
|= itoa64_to_int (buf
[34]) << 12;
2193 l
|= itoa64_to_int (buf
[35]) << 18;
2195 digest
[24] = (l
>> 0) & 0xff;
2196 digest
[25] = (l
>> 8) & 0xff;
2197 digest
[26] = (l
>> 16) & 0xff;
2199 l
= itoa64_to_int (buf
[36]) << 0;
2200 l
|= itoa64_to_int (buf
[37]) << 6;
2201 l
|= itoa64_to_int (buf
[38]) << 12;
2202 l
|= itoa64_to_int (buf
[39]) << 18;
2204 digest
[27] = (l
>> 0) & 0xff;
2205 digest
[28] = (l
>> 8) & 0xff;
2206 digest
[29] = (l
>> 16) & 0xff;
2208 l
= itoa64_to_int (buf
[40]) << 0;
2209 l
|= itoa64_to_int (buf
[41]) << 6;
2210 l
|= itoa64_to_int (buf
[42]) << 12;
2211 l
|= itoa64_to_int (buf
[43]) << 18;
2213 digest
[30] = (l
>> 0) & 0xff;
2214 digest
[31] = (l
>> 8) & 0xff;
2215 digest
[32] = (l
>> 16) & 0xff;
2250 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2254 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2256 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2263 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2270 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[11] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2277 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[15] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2284 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[19] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2291 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[23] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2298 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[27] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2305 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[31] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2312 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[35] = int_to_itoa64 (l
& 0x3f);
2317 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2319 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2321 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2322 buf
[39] = int_to_itoa64 (l
& 0x3f);
2324 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2326 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2328 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2329 //buf[43] = int_to_itoa64 (l & 0x3f);
2337 static struct termio savemodes
;
2338 static int havemodes
= 0;
2342 struct termio modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3409 return (clocksThrottleReasons
> 0);
3415 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3417 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3421 if (data
.hm_device
[device_id
].od_version
== 5)
3423 ADLFanSpeedValue lpFanSpeedValue
;
3425 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3427 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3428 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3429 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3430 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3432 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3436 else // od_version == 6
3438 ADLOD6FanSpeedValue fan_speed_value
;
3440 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3442 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3443 fan_speed_value
.iFanSpeed
= fanspeed
;
3445 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3455 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3457 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3461 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3463 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3465 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3466 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3468 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3477 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3479 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3481 if (data
.hm_xnvctrl
)
3483 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3492 #endif // HAVE_HWMON
3498 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3500 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3502 if (css_cnt
> SP_PW_MAX
)
3504 log_error ("ERROR: Mask length is too long");
3509 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3511 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3513 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3514 uint cs_len
= css
[css_pos
].cs_len
;
3516 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3518 uint c
= cs_buf
[cs_pos
] & 0xff;
3525 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3527 cs_t
*cs
= &css
[css_cnt
];
3529 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3531 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3535 for (i
= 0; i
< cs
->cs_len
; i
++)
3537 const uint u
= cs
->cs_buf
[i
];
3542 for (i
= 0; i
< in_len
; i
++)
3544 uint u
= in_buf
[i
] & 0xff;
3546 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3548 if (css_uniq
[u
] == 1) continue;
3552 cs
->cs_buf
[cs
->cs_len
] = u
;
3560 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3564 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3566 uint p0
= in_buf
[in_pos
] & 0xff;
3568 if (interpret
== 1 && p0
== '?')
3572 if (in_pos
== in_len
) break;
3574 uint p1
= in_buf
[in_pos
] & 0xff;
3578 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3580 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3582 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3584 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3586 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3588 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3590 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3591 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3593 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3594 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3596 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3597 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3599 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3600 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3602 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3604 default: log_error ("Syntax error: %s", in_buf
);
3610 if (data
.hex_charset
)
3614 if (in_pos
== in_len
)
3616 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3621 uint p1
= in_buf
[in_pos
] & 0xff;
3623 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3625 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3632 chr
= hex_convert (p1
) << 0;
3633 chr
|= hex_convert (p0
) << 4;
3635 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3641 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3647 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3651 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3653 sum
*= css
[css_pos
].cs_len
;
3659 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3661 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3666 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3668 char p0
= mask_buf
[mask_pos
];
3674 if (mask_pos
== mask_len
) break;
3676 char p1
= mask_buf
[mask_pos
];
3682 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3684 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3686 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3688 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3690 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3692 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3694 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3695 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3697 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3698 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3700 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3701 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3703 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3704 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3706 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3708 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3714 if (data
.hex_charset
)
3718 // if there is no 2nd hex character, show an error:
3720 if (mask_pos
== mask_len
)
3722 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3727 char p1
= mask_buf
[mask_pos
];
3729 // if they are not valid hex character, show an error:
3731 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3733 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3740 chr
|= hex_convert (p1
) << 0;
3741 chr
|= hex_convert (p0
) << 4;
3743 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3749 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3756 log_error ("ERROR: Invalid mask length (0)");
3766 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3768 for (int i
= 0; i
< css_cnt
; i
++)
3770 uint len
= css
[i
].cs_len
;
3771 u64 next
= val
/ len
;
3772 uint pos
= val
% len
;
3773 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3778 void mp_cut_at (char *mask
, uint max
)
3782 uint mask_len
= strlen (mask
);
3784 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3786 if (mask
[i
] == '?') i
++;
3792 void mp_setup_sys (cs_t
*mp_sys
)
3796 uint donec
[CHARSIZ
] = { 0 };
3798 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3799 mp_sys
[0].cs_buf
[pos
++] = chr
;
3800 mp_sys
[0].cs_len
= pos
; }
3802 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3803 mp_sys
[1].cs_buf
[pos
++] = chr
;
3804 mp_sys
[1].cs_len
= pos
; }
3806 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3807 mp_sys
[2].cs_buf
[pos
++] = chr
;
3808 mp_sys
[2].cs_len
= pos
; }
3810 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3811 mp_sys
[3].cs_buf
[pos
++] = chr
;
3812 mp_sys
[3].cs_len
= pos
; }
3814 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3815 mp_sys
[4].cs_len
= pos
; }
3817 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3818 mp_sys
[5].cs_len
= pos
; }
3821 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3823 FILE *fp
= fopen (buf
, "rb");
3825 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3827 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3831 char mp_file
[1024] = { 0 };
3833 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3837 len
= in_superchop (mp_file
);
3841 log_info ("WARNING: Charset file corrupted");
3843 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3847 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3852 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3854 mp_usr
[index
].cs_len
= 0;
3856 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3859 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3861 char *new_mask_buf
= (char *) mymalloc (256);
3867 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3869 if (css_pos
== len
) break;
3871 char p0
= mask_buf
[mask_pos
];
3873 new_mask_buf
[mask_pos
] = p0
;
3879 if (mask_pos
== mask_len
) break;
3881 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3885 if (data
.hex_charset
)
3889 if (mask_pos
== mask_len
)
3891 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3896 char p1
= mask_buf
[mask_pos
];
3898 // if they are not valid hex character, show an error:
3900 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3902 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3907 new_mask_buf
[mask_pos
] = p1
;
3912 if (css_pos
== len
) return (new_mask_buf
);
3914 myfree (new_mask_buf
);
3923 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3929 for (i
= start
; i
< stop
; i
++)
3931 sum
*= root_css_buf
[i
].cs_len
;
3937 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3941 cs_t
*cs
= &root_css_buf
[start
];
3945 for (i
= start
; i
< stop
; i
++)
3947 const u64 m
= v
% cs
->cs_len
;
3948 const u64 d
= v
/ cs
->cs_len
;
3952 const uint k
= cs
->cs_buf
[m
];
3954 pw_buf
[i
- start
] = (char) k
;
3956 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3960 int sp_comp_val (const void *p1
, const void *p2
)
3962 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3963 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3965 return b2
->val
- b1
->val
;
3968 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3975 * Initialize hcstats
3978 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3980 u64
*root_stats_ptr
= root_stats_buf
;
3982 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3984 for (i
= 0; i
< SP_PW_MAX
; i
++)
3986 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3988 root_stats_ptr
+= CHARSIZ
;
3991 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3993 u64
*markov_stats_ptr
= markov_stats_buf
;
3995 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3997 for (i
= 0; i
< SP_PW_MAX
; i
++)
3999 for (j
= 0; j
< CHARSIZ
; j
++)
4001 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4003 markov_stats_ptr
+= CHARSIZ
;
4013 char hcstat_tmp
[256] = { 0 };
4015 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4017 hcstat
= hcstat_tmp
;
4020 FILE *fd
= fopen (hcstat
, "rb");
4024 log_error ("%s: %s", hcstat
, strerror (errno
));
4029 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4031 log_error ("%s: Could not load data", hcstat
);
4038 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4040 log_error ("%s: Could not load data", hcstat
);
4050 * Markov modifier of hcstat_table on user request
4055 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4056 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4061 /* Add all stats to first position */
4063 for (i
= 1; i
< SP_PW_MAX
; i
++)
4065 u64
*out
= root_stats_buf_by_pos
[0];
4066 u64
*in
= root_stats_buf_by_pos
[i
];
4068 for (j
= 0; j
< CHARSIZ
; j
++)
4074 for (i
= 1; i
< SP_PW_MAX
; i
++)
4076 u64
*out
= markov_stats_buf_by_key
[0][0];
4077 u64
*in
= markov_stats_buf_by_key
[i
][0];
4079 for (j
= 0; j
< CHARSIZ
; j
++)
4081 for (k
= 0; k
< CHARSIZ
; k
++)
4088 /* copy them to all pw_positions */
4090 for (i
= 1; i
< SP_PW_MAX
; i
++)
4092 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4095 for (i
= 1; i
< SP_PW_MAX
; i
++)
4097 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4105 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4107 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4109 for (i
= 0; i
< SP_PW_MAX
; i
++)
4111 root_table_buf_by_pos
[i
] = root_table_ptr
;
4113 root_table_ptr
+= CHARSIZ
;
4116 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4118 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4120 for (i
= 0; i
< SP_PW_MAX
; i
++)
4122 for (j
= 0; j
< CHARSIZ
; j
++)
4124 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4126 markov_table_ptr
+= CHARSIZ
;
4131 * Convert hcstat to tables
4134 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4136 uint key
= i
% CHARSIZ
;
4138 root_table_buf
[i
].key
= key
;
4139 root_table_buf
[i
].val
= root_stats_buf
[i
];
4142 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4144 uint key
= i
% CHARSIZ
;
4146 markov_table_buf
[i
].key
= key
;
4147 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4150 myfree (root_stats_buf
);
4151 myfree (markov_stats_buf
);
4157 for (i
= 0; i
< SP_PW_MAX
; i
++)
4159 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4162 for (i
= 0; i
< SP_PW_MAX
; i
++)
4164 for (j
= 0; j
< CHARSIZ
; j
++)
4166 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4171 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4174 * Convert tables to css
4177 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4179 uint pw_pos
= i
/ CHARSIZ
;
4181 cs_t
*cs
= &root_css_buf
[pw_pos
];
4183 if (cs
->cs_len
== threshold
) continue;
4185 uint key
= root_table_buf
[i
].key
;
4187 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4189 cs
->cs_buf
[cs
->cs_len
] = key
;
4195 * Convert table to css
4198 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4200 uint c
= i
/ CHARSIZ
;
4202 cs_t
*cs
= &markov_css_buf
[c
];
4204 if (cs
->cs_len
== threshold
) continue;
4206 uint pw_pos
= c
/ CHARSIZ
;
4208 uint key
= markov_table_buf
[i
].key
;
4210 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4212 cs
->cs_buf
[cs
->cs_len
] = key
;
4218 for (uint i = 0; i < 8; i++)
4220 for (uint j = 0x20; j < 0x80; j++)
4222 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4224 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4226 for (uint k = 0; k < 10; k++)
4228 printf (" %u\n", ptr->cs_buf[k]);
4235 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4237 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4239 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4249 for (uint j
= 1; j
< CHARSIZ
; j
++)
4259 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4261 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4263 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4265 out
+= CHARSIZ
* CHARSIZ
;
4266 in
+= CHARSIZ
* CHARSIZ
;
4268 for (uint j
= 0; j
< CHARSIZ
; j
++)
4275 for (uint k
= 1; k
< CHARSIZ
; k
++)
4287 * mixed shared functions
4290 void dump_hex (const u8
*s
, const int sz
)
4292 for (int i
= 0; i
< sz
; i
++)
4294 log_info_nn ("%02x ", s
[i
]);
4300 void usage_mini_print (const char *progname
)
4302 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4305 void usage_big_print (const char *progname
)
4307 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4310 char *get_exec_path ()
4312 int exec_path_len
= 1024;
4314 char *exec_path
= (char *) mymalloc (exec_path_len
);
4318 char tmp
[32] = { 0 };
4320 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4322 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4326 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4330 uint size
= exec_path_len
;
4332 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4334 log_error("! executable path buffer too small\n");
4339 const int len
= strlen (exec_path
);
4342 #error Your Operating System is not supported or detected
4350 char *get_install_dir (const char *progname
)
4352 char *install_dir
= mystrdup (progname
);
4353 char *last_slash
= NULL
;
4355 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4359 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4365 install_dir
[0] = '.';
4369 return (install_dir
);
4372 char *get_profile_dir (const char *homedir
)
4374 #define DOT_HASHCAT ".hashcat"
4376 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4378 char *profile_dir
= (char *) mymalloc (len
+ 1);
4380 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4385 char *get_session_dir (const char *profile_dir
)
4387 #define SESSIONS_FOLDER "sessions"
4389 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4391 char *session_dir
= (char *) mymalloc (len
+ 1);
4393 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4398 uint
count_lines (FILE *fd
)
4402 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4408 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4410 if (nread
< 1) continue;
4414 for (i
= 0; i
< nread
; i
++)
4416 if (prev
== '\n') cnt
++;
4427 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4431 FILE *fd
= fopen (filename
, "rb");
4435 log_error ("%s: %s", filename
, strerror (errno
));
4440 #define MAX_KEY_SIZE (1024 * 1024)
4442 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4444 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4450 for (int fpos
= 0; fpos
< nread
; fpos
++)
4452 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4454 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4455 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4456 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4457 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4459 if (kpos
>= 64) kpos
= 0;
4466 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4470 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4471 if (CPU_ISSET(core
, cpu_set
)) break;
4473 thread_affinity_policy_data_t policy
= { core
};
4475 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4477 if (data
.quiet
== 0)
4479 if (rc
!= KERN_SUCCESS
)
4481 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4489 void set_cpu_affinity (char *cpu_affinity
)
4492 DWORD_PTR aff_mask
= 0;
4500 char *devices
= strdup (cpu_affinity
);
4502 char *next
= strtok (devices
, ",");
4506 uint cpu_id
= atoi (next
);
4521 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4527 aff_mask
|= 1 << (cpu_id
- 1);
4529 CPU_SET ((cpu_id
- 1), &cpuset
);
4532 } while ((next
= strtok (NULL
, ",")) != NULL
);
4538 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4539 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4541 pthread_t thread
= pthread_self ();
4542 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4546 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4548 char *element
, *end
;
4550 end
= (char *) base
+ nmemb
* size
;
4552 for (element
= (char *) base
; element
< end
; element
+= size
)
4553 if (!compar (element
, key
))
4559 int sort_by_u32 (const void *v1
, const void *v2
)
4561 const u32
*s1
= (const u32
*) v1
;
4562 const u32
*s2
= (const u32
*) v2
;
4567 int sort_by_salt (const void *v1
, const void *v2
)
4569 const salt_t
*s1
= (const salt_t
*) v1
;
4570 const salt_t
*s2
= (const salt_t
*) v2
;
4572 const int res1
= s1
->salt_len
- s2
->salt_len
;
4574 if (res1
!= 0) return (res1
);
4576 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4578 if (res2
!= 0) return (res2
);
4586 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4587 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4594 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4595 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4601 int sort_by_salt_buf (const void *v1
, const void *v2
)
4603 const pot_t
*p1
= (const pot_t
*) v1
;
4604 const pot_t
*p2
= (const pot_t
*) v2
;
4606 const hash_t
*h1
= &p1
->hash
;
4607 const hash_t
*h2
= &p2
->hash
;
4609 const salt_t
*s1
= h1
->salt
;
4610 const salt_t
*s2
= h2
->salt
;
4616 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4617 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4623 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4625 const hash_t
*h1
= (const hash_t
*) v1
;
4626 const hash_t
*h2
= (const hash_t
*) v2
;
4628 const salt_t
*s1
= h1
->salt
;
4629 const salt_t
*s2
= h2
->salt
;
4631 // testphase: this should work
4636 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4637 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4640 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4641 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4642 if (s1->salt_len > s2->salt_len) return ( 1);
4643 if (s1->salt_len < s2->salt_len) return (-1);
4645 uint n = s1->salt_len;
4649 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4650 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4657 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4659 const hash_t
*h1
= (const hash_t
*) v1
;
4660 const hash_t
*h2
= (const hash_t
*) v2
;
4662 const salt_t
*s1
= h1
->salt
;
4663 const salt_t
*s2
= h2
->salt
;
4665 // 16 - 2 (since last 2 uints contain the digest)
4670 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4671 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4677 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4679 const hash_t
*h1
= (const hash_t
*) v1
;
4680 const hash_t
*h2
= (const hash_t
*) v2
;
4682 const void *d1
= h1
->digest
;
4683 const void *d2
= h2
->digest
;
4685 return data
.sort_by_digest (d1
, d2
);
4688 int sort_by_hash (const void *v1
, const void *v2
)
4690 const hash_t
*h1
= (const hash_t
*) v1
;
4691 const hash_t
*h2
= (const hash_t
*) v2
;
4695 const salt_t
*s1
= h1
->salt
;
4696 const salt_t
*s2
= h2
->salt
;
4698 int res
= sort_by_salt (s1
, s2
);
4700 if (res
!= 0) return (res
);
4703 const void *d1
= h1
->digest
;
4704 const void *d2
= h2
->digest
;
4706 return data
.sort_by_digest (d1
, d2
);
4709 int sort_by_pot (const void *v1
, const void *v2
)
4711 const pot_t
*p1
= (const pot_t
*) v1
;
4712 const pot_t
*p2
= (const pot_t
*) v2
;
4714 const hash_t
*h1
= &p1
->hash
;
4715 const hash_t
*h2
= &p2
->hash
;
4717 return sort_by_hash (h1
, h2
);
4720 int sort_by_mtime (const void *p1
, const void *p2
)
4722 const char **f1
= (const char **) p1
;
4723 const char **f2
= (const char **) p2
;
4725 struct stat s1
; stat (*f1
, &s1
);
4726 struct stat s2
; stat (*f2
, &s2
);
4728 return s2
.st_mtime
- s1
.st_mtime
;
4731 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4733 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4734 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4736 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4739 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4741 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4742 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4744 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4747 int sort_by_stringptr (const void *p1
, const void *p2
)
4749 const char **s1
= (const char **) p1
;
4750 const char **s2
= (const char **) p2
;
4752 return strcmp (*s1
, *s2
);
4755 int sort_by_dictstat (const void *s1
, const void *s2
)
4757 dictstat_t
*d1
= (dictstat_t
*) s1
;
4758 dictstat_t
*d2
= (dictstat_t
*) s2
;
4761 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4763 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4766 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4769 int sort_by_bitmap (const void *p1
, const void *p2
)
4771 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4772 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4774 return b1
->collisions
- b2
->collisions
;
4777 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4779 const u32
*d1
= (const u32
*) v1
;
4780 const u32
*d2
= (const u32
*) v2
;
4786 if (d1
[n
] > d2
[n
]) return ( 1);
4787 if (d1
[n
] < d2
[n
]) return (-1);
4793 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4795 const u32
*d1
= (const u32
*) v1
;
4796 const u32
*d2
= (const u32
*) v2
;
4802 if (d1
[n
] > d2
[n
]) return ( 1);
4803 if (d1
[n
] < d2
[n
]) return (-1);
4809 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4811 const u32
*d1
= (const u32
*) v1
;
4812 const u32
*d2
= (const u32
*) v2
;
4818 if (d1
[n
] > d2
[n
]) return ( 1);
4819 if (d1
[n
] < d2
[n
]) return (-1);
4825 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4827 const u32
*d1
= (const u32
*) v1
;
4828 const u32
*d2
= (const u32
*) v2
;
4834 if (d1
[n
] > d2
[n
]) return ( 1);
4835 if (d1
[n
] < d2
[n
]) return (-1);
4841 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4843 const u32
*d1
= (const u32
*) v1
;
4844 const u32
*d2
= (const u32
*) v2
;
4850 if (d1
[n
] > d2
[n
]) return ( 1);
4851 if (d1
[n
] < d2
[n
]) return (-1);
4857 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4859 const u32
*d1
= (const u32
*) v1
;
4860 const u32
*d2
= (const u32
*) v2
;
4866 if (d1
[n
] > d2
[n
]) return ( 1);
4867 if (d1
[n
] < d2
[n
]) return (-1);
4873 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4875 const u32
*d1
= (const u32
*) v1
;
4876 const u32
*d2
= (const u32
*) v2
;
4882 if (d1
[n
] > d2
[n
]) return ( 1);
4883 if (d1
[n
] < d2
[n
]) return (-1);
4889 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4891 const u32
*d1
= (const u32
*) v1
;
4892 const u32
*d2
= (const u32
*) v2
;
4898 if (d1
[n
] > d2
[n
]) return ( 1);
4899 if (d1
[n
] < d2
[n
]) return (-1);
4905 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4907 const u64
*d1
= (const u64
*) v1
;
4908 const u64
*d2
= (const u64
*) v2
;
4914 if (d1
[n
] > d2
[n
]) return ( 1);
4915 if (d1
[n
] < d2
[n
]) return (-1);
4921 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4923 const u64
*d1
= (const u64
*) v1
;
4924 const u64
*d2
= (const u64
*) v2
;
4930 if (d1
[n
] > d2
[n
]) return ( 1);
4931 if (d1
[n
] < d2
[n
]) return (-1);
4937 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4939 const u64
*d1
= (const u64
*) v1
;
4940 const u64
*d2
= (const u64
*) v2
;
4946 if (d1
[n
] > d2
[n
]) return ( 1);
4947 if (d1
[n
] < d2
[n
]) return (-1);
4953 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4955 const u32
*d1
= (const u32
*) v1
;
4956 const u32
*d2
= (const u32
*) v2
;
4958 const uint dgst_pos0
= data
.dgst_pos0
;
4959 const uint dgst_pos1
= data
.dgst_pos1
;
4960 const uint dgst_pos2
= data
.dgst_pos2
;
4961 const uint dgst_pos3
= data
.dgst_pos3
;
4963 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4964 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4965 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4966 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4967 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4968 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4969 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4970 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4975 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4977 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4978 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4980 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4982 if (res1
!= 0) return (res1
);
4987 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4989 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4990 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4992 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4994 if (res1
!= 0) return (res1
);
4996 const int res2
= t1
->attack_mode
4999 if (res2
!= 0) return (res2
);
5001 const int res3
= t1
->hash_type
5004 if (res3
!= 0) return (res3
);
5009 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
5011 uint outfile_autohex
= data
.outfile_autohex
;
5013 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5015 FILE *debug_fp
= NULL
;
5017 if (debug_file
!= NULL
)
5019 debug_fp
= fopen (debug_file
, "ab");
5021 lock_file (debug_fp
);
5028 if (debug_fp
== NULL
)
5030 log_info ("WARNING: Could not open debug-file for writing");
5034 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5036 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5038 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5041 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5043 if (debug_mode
== 4)
5045 fputc (':', debug_fp
);
5047 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5050 fputc ('\n', debug_fp
);
5052 if (debug_file
!= NULL
) fclose (debug_fp
);
5056 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5058 int needs_hexify
= 0;
5060 if (outfile_autohex
== 1)
5062 for (uint i
= 0; i
< plain_len
; i
++)
5064 if (plain_ptr
[i
] < 0x20)
5071 if (plain_ptr
[i
] > 0x7f)
5080 if (needs_hexify
== 1)
5082 fprintf (fp
, "$HEX[");
5084 for (uint i
= 0; i
< plain_len
; i
++)
5086 fprintf (fp
, "%02x", plain_ptr
[i
]);
5093 fwrite (plain_ptr
, plain_len
, 1, fp
);
5097 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
5099 uint outfile_format
= data
.outfile_format
;
5101 char separator
= data
.separator
;
5103 if (outfile_format
& OUTFILE_FMT_HASH
)
5105 fprintf (out_fp
, "%s", out_buf
);
5107 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5109 fputc (separator
, out_fp
);
5112 else if (data
.username
)
5114 if (username
!= NULL
)
5116 for (uint i
= 0; i
< user_len
; i
++)
5118 fprintf (out_fp
, "%c", username
[i
]);
5121 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5123 fputc (separator
, out_fp
);
5128 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5130 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5132 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5134 fputc (separator
, out_fp
);
5138 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5140 for (uint i
= 0; i
< plain_len
; i
++)
5142 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5145 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5147 fputc (separator
, out_fp
);
5151 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5154 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5159 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5161 fprintf (out_fp
, "%llu", crackpos
);
5166 fputc ('\n', out_fp
);
5169 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5173 pot_key
.hash
.salt
= hashes_buf
->salt
;
5174 pot_key
.hash
.digest
= hashes_buf
->digest
;
5176 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5182 input_buf
[input_len
] = 0;
5185 unsigned char *username
= NULL
;
5190 user_t
*user
= hashes_buf
->hash_info
->user
;
5194 username
= (unsigned char *) (user
->user_name
);
5196 user_len
= user
->user_len
;
5200 // do output the line
5201 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5205 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5206 #define LM_MASKED_PLAIN "[notfound]"
5208 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5214 pot_left_key
.hash
.salt
= hash_left
->salt
;
5215 pot_left_key
.hash
.digest
= hash_left
->digest
;
5217 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5221 uint weak_hash_found
= 0;
5223 pot_t pot_right_key
;
5225 pot_right_key
.hash
.salt
= hash_right
->salt
;
5226 pot_right_key
.hash
.digest
= hash_right
->digest
;
5228 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5230 if (pot_right_ptr
== NULL
)
5232 // special case, if "weak hash"
5234 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5236 weak_hash_found
= 1;
5238 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5240 // in theory this is not needed, but we are paranoia:
5242 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5243 pot_right_ptr
->plain_len
= 0;
5247 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5249 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5254 // at least one half was found:
5258 input_buf
[input_len
] = 0;
5262 unsigned char *username
= NULL
;
5267 user_t
*user
= hash_left
->hash_info
->user
;
5271 username
= (unsigned char *) (user
->user_name
);
5273 user_len
= user
->user_len
;
5277 // mask the part which was not found
5279 uint left_part_masked
= 0;
5280 uint right_part_masked
= 0;
5282 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5284 if (pot_left_ptr
== NULL
)
5286 left_part_masked
= 1;
5288 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5290 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5292 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5293 pot_left_ptr
->plain_len
= mask_plain_len
;
5296 if (pot_right_ptr
== NULL
)
5298 right_part_masked
= 1;
5300 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5302 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5304 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5305 pot_right_ptr
->plain_len
= mask_plain_len
;
5308 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5312 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5314 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5316 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5318 // do output the line
5320 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5322 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5324 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5325 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5328 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5332 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5334 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5336 if (pot_ptr
== NULL
)
5340 input_buf
[input_len
] = 0;
5342 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5346 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5352 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5354 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5358 pot_t pot_right_key
;
5360 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5362 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5364 uint weak_hash_found
= 0;
5366 if (pot_right_ptr
== NULL
)
5368 // special case, if "weak hash"
5370 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5372 weak_hash_found
= 1;
5374 // we just need that pot_right_ptr is not a NULL pointer
5376 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5380 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5382 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5387 // ... at least one part was not cracked
5391 input_buf
[input_len
] = 0;
5393 // only show the hash part which is still not cracked
5395 uint user_len
= input_len
- 32;
5397 char *hash_output
= (char *) mymalloc (33);
5399 memcpy (hash_output
, input_buf
, input_len
);
5401 if (pot_left_ptr
!= NULL
)
5403 // only show right part (because left part was already found)
5405 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5407 hash_output
[user_len
+ 16] = 0;
5410 if (pot_right_ptr
!= NULL
)
5412 // only show left part (because right part was already found)
5414 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5416 hash_output
[user_len
+ 16] = 0;
5419 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5421 myfree (hash_output
);
5423 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5426 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5428 uint opencl_platforms_filter
= 0;
5430 if (opencl_platforms
)
5432 char *platforms
= strdup (opencl_platforms
);
5434 char *next
= strtok (platforms
, ",");
5438 int platform
= atoi (next
);
5440 if (platform
< 1 || platform
> 32)
5442 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5447 opencl_platforms_filter
|= 1 << (platform
- 1);
5449 } while ((next
= strtok (NULL
, ",")) != NULL
);
5455 opencl_platforms_filter
= -1;
5458 return opencl_platforms_filter
;
5461 u32
setup_devices_filter (char *opencl_devices
)
5463 u32 devices_filter
= 0;
5467 char *devices
= strdup (opencl_devices
);
5469 char *next
= strtok (devices
, ",");
5473 int device_id
= atoi (next
);
5475 if (device_id
< 1 || device_id
> 32)
5477 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5482 devices_filter
|= 1 << (device_id
- 1);
5484 } while ((next
= strtok (NULL
, ",")) != NULL
);
5490 devices_filter
= -1;
5493 return devices_filter
;
5496 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5498 cl_device_type device_types_filter
= 0;
5500 if (opencl_device_types
)
5502 char *device_types
= strdup (opencl_device_types
);
5504 char *next
= strtok (device_types
, ",");
5508 int device_type
= atoi (next
);
5510 if (device_type
< 1 || device_type
> 3)
5512 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5517 device_types_filter
|= 1 << device_type
;
5519 } while ((next
= strtok (NULL
, ",")) != NULL
);
5521 free (device_types
);
5525 // Do not use CPU by default, this often reduces GPU performance because
5526 // the CPU is too busy to handle GPU synchronization
5528 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5531 return device_types_filter
;
5534 u32
get_random_num (const u32 min
, const u32 max
)
5536 if (min
== max
) return (min
);
5538 return ((rand () % (max
- min
)) + min
);
5541 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5543 u32 quotient
= dividend
/ divisor
;
5545 if (dividend
% divisor
) quotient
++;
5550 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5552 u64 quotient
= dividend
/ divisor
;
5554 if (dividend
% divisor
) quotient
++;
5559 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5561 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5562 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5564 if (tm
->tm_year
- 70)
5566 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5567 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5569 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5571 else if (tm
->tm_yday
)
5573 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5574 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5576 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5578 else if (tm
->tm_hour
)
5580 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5581 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5583 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5585 else if (tm
->tm_min
)
5587 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5588 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5590 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5594 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5596 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5600 void format_speed_display (float val
, char *buf
, size_t len
)
5611 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5622 /* generate output */
5626 snprintf (buf
, len
- 1, "%.0f ", val
);
5630 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5634 void lowercase (u8
*buf
, int len
)
5636 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5639 void uppercase (u8
*buf
, int len
)
5641 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5644 int fgetl (FILE *fp
, char *line_buf
)
5650 const int c
= fgetc (fp
);
5652 if (c
== EOF
) break;
5654 line_buf
[line_len
] = (char) c
;
5658 if (line_len
== HCBUFSIZ
) line_len
--;
5660 if (c
== '\n') break;
5663 if (line_len
== 0) return 0;
5665 if (line_buf
[line_len
- 1] == '\n')
5669 line_buf
[line_len
] = 0;
5672 if (line_len
== 0) return 0;
5674 if (line_buf
[line_len
- 1] == '\r')
5678 line_buf
[line_len
] = 0;
5684 int in_superchop (char *buf
)
5686 int len
= strlen (buf
);
5690 if (buf
[len
- 1] == '\n')
5697 if (buf
[len
- 1] == '\r')
5712 char **scan_directory (const char *path
)
5714 char *tmp_path
= mystrdup (path
);
5716 size_t tmp_path_len
= strlen (tmp_path
);
5718 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5720 tmp_path
[tmp_path_len
- 1] = 0;
5722 tmp_path_len
= strlen (tmp_path
);
5725 char **files
= NULL
;
5731 if ((d
= opendir (tmp_path
)) != NULL
)
5737 memset (&e
, 0, sizeof (e
));
5738 struct dirent
*de
= NULL
;
5740 if (readdir_r (d
, &e
, &de
) != 0)
5742 log_error ("ERROR: readdir_r() failed");
5747 if (de
== NULL
) break;
5751 while ((de
= readdir (d
)) != NULL
)
5754 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5756 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5758 char *path_file
= (char *) mymalloc (path_size
+ 1);
5760 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5762 path_file
[path_size
] = 0;
5766 if ((d_test
= opendir (path_file
)) != NULL
)
5774 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5778 files
[num_files
- 1] = path_file
;
5784 else if (errno
== ENOTDIR
)
5786 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5790 files
[num_files
- 1] = mystrdup (path
);
5793 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5797 files
[num_files
- 1] = NULL
;
5804 int count_dictionaries (char **dictionary_files
)
5806 if (dictionary_files
== NULL
) return 0;
5810 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5818 char *stroptitype (const uint opti_type
)
5822 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5823 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5824 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5825 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5826 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5827 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5828 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5829 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5830 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5831 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5832 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5833 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5834 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5835 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5836 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5837 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5838 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5839 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5840 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5846 char *strparser (const uint parser_status
)
5848 switch (parser_status
)
5850 case PARSER_OK
: return ((char *) PA_000
); break;
5851 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5852 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5853 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5854 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5855 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5856 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5857 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5858 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5859 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5860 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5861 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5862 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5863 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5864 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5865 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5866 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5869 return ((char *) PA_255
);
5872 char *strhashtype (const uint hash_mode
)
5876 case 0: return ((char *) HT_00000
); break;
5877 case 10: return ((char *) HT_00010
); break;
5878 case 11: return ((char *) HT_00011
); break;
5879 case 12: return ((char *) HT_00012
); break;
5880 case 20: return ((char *) HT_00020
); break;
5881 case 21: return ((char *) HT_00021
); break;
5882 case 22: return ((char *) HT_00022
); break;
5883 case 23: return ((char *) HT_00023
); break;
5884 case 30: return ((char *) HT_00030
); break;
5885 case 40: return ((char *) HT_00040
); break;
5886 case 50: return ((char *) HT_00050
); break;
5887 case 60: return ((char *) HT_00060
); break;
5888 case 100: return ((char *) HT_00100
); break;
5889 case 101: return ((char *) HT_00101
); break;
5890 case 110: return ((char *) HT_00110
); break;
5891 case 111: return ((char *) HT_00111
); break;
5892 case 112: return ((char *) HT_00112
); break;
5893 case 120: return ((char *) HT_00120
); break;
5894 case 121: return ((char *) HT_00121
); break;
5895 case 122: return ((char *) HT_00122
); break;
5896 case 124: return ((char *) HT_00124
); break;
5897 case 125: return ((char *) HT_00125
); break;
5898 case 130: return ((char *) HT_00130
); break;
5899 case 131: return ((char *) HT_00131
); break;
5900 case 132: return ((char *) HT_00132
); break;
5901 case 133: return ((char *) HT_00133
); break;
5902 case 140: return ((char *) HT_00140
); break;
5903 case 141: return ((char *) HT_00141
); break;
5904 case 150: return ((char *) HT_00150
); break;
5905 case 160: return ((char *) HT_00160
); break;
5906 case 190: return ((char *) HT_00190
); break;
5907 case 200: return ((char *) HT_00200
); break;
5908 case 300: return ((char *) HT_00300
); break;
5909 case 400: return ((char *) HT_00400
); break;
5910 case 500: return ((char *) HT_00500
); break;
5911 case 501: return ((char *) HT_00501
); break;
5912 case 900: return ((char *) HT_00900
); break;
5913 case 910: return ((char *) HT_00910
); break;
5914 case 1000: return ((char *) HT_01000
); break;
5915 case 1100: return ((char *) HT_01100
); break;
5916 case 1400: return ((char *) HT_01400
); break;
5917 case 1410: return ((char *) HT_01410
); break;
5918 case 1420: return ((char *) HT_01420
); break;
5919 case 1421: return ((char *) HT_01421
); break;
5920 case 1430: return ((char *) HT_01430
); break;
5921 case 1440: return ((char *) HT_01440
); break;
5922 case 1441: return ((char *) HT_01441
); break;
5923 case 1450: return ((char *) HT_01450
); break;
5924 case 1460: return ((char *) HT_01460
); break;
5925 case 1500: return ((char *) HT_01500
); break;
5926 case 1600: return ((char *) HT_01600
); break;
5927 case 1700: return ((char *) HT_01700
); break;
5928 case 1710: return ((char *) HT_01710
); break;
5929 case 1711: return ((char *) HT_01711
); break;
5930 case 1720: return ((char *) HT_01720
); break;
5931 case 1722: return ((char *) HT_01722
); break;
5932 case 1730: return ((char *) HT_01730
); break;
5933 case 1731: return ((char *) HT_01731
); break;
5934 case 1740: return ((char *) HT_01740
); break;
5935 case 1750: return ((char *) HT_01750
); break;
5936 case 1760: return ((char *) HT_01760
); break;
5937 case 1800: return ((char *) HT_01800
); break;
5938 case 2100: return ((char *) HT_02100
); break;
5939 case 2400: return ((char *) HT_02400
); break;
5940 case 2410: return ((char *) HT_02410
); break;
5941 case 2500: return ((char *) HT_02500
); break;
5942 case 2600: return ((char *) HT_02600
); break;
5943 case 2611: return ((char *) HT_02611
); break;
5944 case 2612: return ((char *) HT_02612
); break;
5945 case 2711: return ((char *) HT_02711
); break;
5946 case 2811: return ((char *) HT_02811
); break;
5947 case 3000: return ((char *) HT_03000
); break;
5948 case 3100: return ((char *) HT_03100
); break;
5949 case 3200: return ((char *) HT_03200
); break;
5950 case 3710: return ((char *) HT_03710
); break;
5951 case 3711: return ((char *) HT_03711
); break;
5952 case 3800: return ((char *) HT_03800
); break;
5953 case 4300: return ((char *) HT_04300
); break;
5954 case 4400: return ((char *) HT_04400
); break;
5955 case 4500: return ((char *) HT_04500
); break;
5956 case 4700: return ((char *) HT_04700
); break;
5957 case 4800: return ((char *) HT_04800
); break;
5958 case 4900: return ((char *) HT_04900
); break;
5959 case 5000: return ((char *) HT_05000
); break;
5960 case 5100: return ((char *) HT_05100
); break;
5961 case 5200: return ((char *) HT_05200
); break;
5962 case 5300: return ((char *) HT_05300
); break;
5963 case 5400: return ((char *) HT_05400
); break;
5964 case 5500: return ((char *) HT_05500
); break;
5965 case 5600: return ((char *) HT_05600
); break;
5966 case 5700: return ((char *) HT_05700
); break;
5967 case 5800: return ((char *) HT_05800
); break;
5968 case 6000: return ((char *) HT_06000
); break;
5969 case 6100: return ((char *) HT_06100
); break;
5970 case 6211: return ((char *) HT_06211
); break;
5971 case 6212: return ((char *) HT_06212
); break;
5972 case 6213: return ((char *) HT_06213
); break;
5973 case 6221: return ((char *) HT_06221
); break;
5974 case 6222: return ((char *) HT_06222
); break;
5975 case 6223: return ((char *) HT_06223
); break;
5976 case 6231: return ((char *) HT_06231
); break;
5977 case 6232: return ((char *) HT_06232
); break;
5978 case 6233: return ((char *) HT_06233
); break;
5979 case 6241: return ((char *) HT_06241
); break;
5980 case 6242: return ((char *) HT_06242
); break;
5981 case 6243: return ((char *) HT_06243
); break;
5982 case 6300: return ((char *) HT_06300
); break;
5983 case 6400: return ((char *) HT_06400
); break;
5984 case 6500: return ((char *) HT_06500
); break;
5985 case 6600: return ((char *) HT_06600
); break;
5986 case 6700: return ((char *) HT_06700
); break;
5987 case 6800: return ((char *) HT_06800
); break;
5988 case 6900: return ((char *) HT_06900
); break;
5989 case 7100: return ((char *) HT_07100
); break;
5990 case 7200: return ((char *) HT_07200
); break;
5991 case 7300: return ((char *) HT_07300
); break;
5992 case 7400: return ((char *) HT_07400
); break;
5993 case 7500: return ((char *) HT_07500
); break;
5994 case 7600: return ((char *) HT_07600
); break;
5995 case 7700: return ((char *) HT_07700
); break;
5996 case 7800: return ((char *) HT_07800
); break;
5997 case 7900: return ((char *) HT_07900
); break;
5998 case 8000: return ((char *) HT_08000
); break;
5999 case 8100: return ((char *) HT_08100
); break;
6000 case 8200: return ((char *) HT_08200
); break;
6001 case 8300: return ((char *) HT_08300
); break;
6002 case 8400: return ((char *) HT_08400
); break;
6003 case 8500: return ((char *) HT_08500
); break;
6004 case 8600: return ((char *) HT_08600
); break;
6005 case 8700: return ((char *) HT_08700
); break;
6006 case 8800: return ((char *) HT_08800
); break;
6007 case 8900: return ((char *) HT_08900
); break;
6008 case 9000: return ((char *) HT_09000
); break;
6009 case 9100: return ((char *) HT_09100
); break;
6010 case 9200: return ((char *) HT_09200
); break;
6011 case 9300: return ((char *) HT_09300
); break;
6012 case 9400: return ((char *) HT_09400
); break;
6013 case 9500: return ((char *) HT_09500
); break;
6014 case 9600: return ((char *) HT_09600
); break;
6015 case 9700: return ((char *) HT_09700
); break;
6016 case 9710: return ((char *) HT_09710
); break;
6017 case 9720: return ((char *) HT_09720
); break;
6018 case 9800: return ((char *) HT_09800
); break;
6019 case 9810: return ((char *) HT_09810
); break;
6020 case 9820: return ((char *) HT_09820
); break;
6021 case 9900: return ((char *) HT_09900
); break;
6022 case 10000: return ((char *) HT_10000
); break;
6023 case 10100: return ((char *) HT_10100
); break;
6024 case 10200: return ((char *) HT_10200
); break;
6025 case 10300: return ((char *) HT_10300
); break;
6026 case 10400: return ((char *) HT_10400
); break;
6027 case 10410: return ((char *) HT_10410
); break;
6028 case 10420: return ((char *) HT_10420
); break;
6029 case 10500: return ((char *) HT_10500
); break;
6030 case 10600: return ((char *) HT_10600
); break;
6031 case 10700: return ((char *) HT_10700
); break;
6032 case 10800: return ((char *) HT_10800
); break;
6033 case 10900: return ((char *) HT_10900
); break;
6034 case 11000: return ((char *) HT_11000
); break;
6035 case 11100: return ((char *) HT_11100
); break;
6036 case 11200: return ((char *) HT_11200
); break;
6037 case 11300: return ((char *) HT_11300
); break;
6038 case 11400: return ((char *) HT_11400
); break;
6039 case 11500: return ((char *) HT_11500
); break;
6040 case 11600: return ((char *) HT_11600
); break;
6041 case 11700: return ((char *) HT_11700
); break;
6042 case 11800: return ((char *) HT_11800
); break;
6043 case 11900: return ((char *) HT_11900
); break;
6044 case 12000: return ((char *) HT_12000
); break;
6045 case 12100: return ((char *) HT_12100
); break;
6046 case 12200: return ((char *) HT_12200
); break;
6047 case 12300: return ((char *) HT_12300
); break;
6048 case 12400: return ((char *) HT_12400
); break;
6049 case 12500: return ((char *) HT_12500
); break;
6050 case 12600: return ((char *) HT_12600
); break;
6051 case 12700: return ((char *) HT_12700
); break;
6052 case 12800: return ((char *) HT_12800
); break;
6053 case 12900: return ((char *) HT_12900
); break;
6054 case 13000: return ((char *) HT_13000
); break;
6055 case 13100: return ((char *) HT_13100
); break;
6056 case 13200: return ((char *) HT_13200
); break;
6057 case 13300: return ((char *) HT_13300
); break;
6058 case 13400: return ((char *) HT_13400
); break;
6059 case 13500: return ((char *) HT_13500
); break;
6060 case 13600: return ((char *) HT_13600
); break;
6061 case 13711: return ((char *) HT_13711
); break;
6062 case 13712: return ((char *) HT_13712
); break;
6063 case 13713: return ((char *) HT_13713
); break;
6064 case 13721: return ((char *) HT_13721
); break;
6065 case 13722: return ((char *) HT_13722
); break;
6066 case 13723: return ((char *) HT_13723
); break;
6067 case 13731: return ((char *) HT_13731
); break;
6068 case 13732: return ((char *) HT_13732
); break;
6069 case 13733: return ((char *) HT_13733
); break;
6070 case 13741: return ((char *) HT_13741
); break;
6071 case 13742: return ((char *) HT_13742
); break;
6072 case 13743: return ((char *) HT_13743
); break;
6073 case 13751: return ((char *) HT_13751
); break;
6074 case 13752: return ((char *) HT_13752
); break;
6075 case 13753: return ((char *) HT_13753
); break;
6076 case 13761: return ((char *) HT_13761
); break;
6077 case 13762: return ((char *) HT_13762
); break;
6078 case 13763: return ((char *) HT_13763
); break;
6079 case 13800: return ((char *) HT_13800
); break;
6082 return ((char *) "Unknown");
6085 char *strstatus (const uint devices_status
)
6087 switch (devices_status
)
6089 case STATUS_INIT
: return ((char *) ST_0000
); break;
6090 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6091 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6092 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6093 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6094 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6095 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6096 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6097 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6098 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6099 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6102 return ((char *) "Unknown");
6105 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6107 uint hash_type
= data
.hash_type
;
6108 uint hash_mode
= data
.hash_mode
;
6109 uint salt_type
= data
.salt_type
;
6110 uint opts_type
= data
.opts_type
;
6111 uint opti_type
= data
.opti_type
;
6112 uint dgst_size
= data
.dgst_size
;
6114 char *hashfile
= data
.hashfile
;
6118 uint digest_buf
[64] = { 0 };
6120 u64
*digest_buf64
= (u64
*) digest_buf
;
6122 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6124 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6126 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6132 case HASH_TYPE_DESCRYPT
:
6133 FP (digest_buf
[1], digest_buf
[0], tt
);
6136 case HASH_TYPE_DESRACF
:
6137 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6138 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6140 FP (digest_buf
[1], digest_buf
[0], tt
);
6144 FP (digest_buf
[1], digest_buf
[0], tt
);
6147 case HASH_TYPE_NETNTLM
:
6148 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6149 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6150 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6151 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6153 FP (digest_buf
[1], digest_buf
[0], tt
);
6154 FP (digest_buf
[3], digest_buf
[2], tt
);
6157 case HASH_TYPE_BSDICRYPT
:
6158 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6159 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6161 FP (digest_buf
[1], digest_buf
[0], tt
);
6166 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6171 digest_buf
[0] += MD4M_A
;
6172 digest_buf
[1] += MD4M_B
;
6173 digest_buf
[2] += MD4M_C
;
6174 digest_buf
[3] += MD4M_D
;
6178 digest_buf
[0] += MD5M_A
;
6179 digest_buf
[1] += MD5M_B
;
6180 digest_buf
[2] += MD5M_C
;
6181 digest_buf
[3] += MD5M_D
;
6184 case HASH_TYPE_SHA1
:
6185 digest_buf
[0] += SHA1M_A
;
6186 digest_buf
[1] += SHA1M_B
;
6187 digest_buf
[2] += SHA1M_C
;
6188 digest_buf
[3] += SHA1M_D
;
6189 digest_buf
[4] += SHA1M_E
;
6192 case HASH_TYPE_SHA256
:
6193 digest_buf
[0] += SHA256M_A
;
6194 digest_buf
[1] += SHA256M_B
;
6195 digest_buf
[2] += SHA256M_C
;
6196 digest_buf
[3] += SHA256M_D
;
6197 digest_buf
[4] += SHA256M_E
;
6198 digest_buf
[5] += SHA256M_F
;
6199 digest_buf
[6] += SHA256M_G
;
6200 digest_buf
[7] += SHA256M_H
;
6203 case HASH_TYPE_SHA384
:
6204 digest_buf64
[0] += SHA384M_A
;
6205 digest_buf64
[1] += SHA384M_B
;
6206 digest_buf64
[2] += SHA384M_C
;
6207 digest_buf64
[3] += SHA384M_D
;
6208 digest_buf64
[4] += SHA384M_E
;
6209 digest_buf64
[5] += SHA384M_F
;
6210 digest_buf64
[6] += 0;
6211 digest_buf64
[7] += 0;
6214 case HASH_TYPE_SHA512
:
6215 digest_buf64
[0] += SHA512M_A
;
6216 digest_buf64
[1] += SHA512M_B
;
6217 digest_buf64
[2] += SHA512M_C
;
6218 digest_buf64
[3] += SHA512M_D
;
6219 digest_buf64
[4] += SHA512M_E
;
6220 digest_buf64
[5] += SHA512M_F
;
6221 digest_buf64
[6] += SHA512M_G
;
6222 digest_buf64
[7] += SHA512M_H
;
6227 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6229 if (dgst_size
== DGST_SIZE_4_2
)
6231 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6233 else if (dgst_size
== DGST_SIZE_4_4
)
6235 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6237 else if (dgst_size
== DGST_SIZE_4_5
)
6239 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6241 else if (dgst_size
== DGST_SIZE_4_6
)
6243 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6245 else if (dgst_size
== DGST_SIZE_4_8
)
6247 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6249 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6251 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6253 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6255 else if (hash_type
== HASH_TYPE_SHA384
)
6257 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6259 else if (hash_type
== HASH_TYPE_SHA512
)
6261 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6263 else if (hash_type
== HASH_TYPE_GOST
)
6265 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6268 else if (dgst_size
== DGST_SIZE_4_64
)
6270 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6272 else if (dgst_size
== DGST_SIZE_8_25
)
6274 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6278 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6279 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6280 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6286 memset (&salt
, 0, sizeof (salt_t
));
6288 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6290 char *ptr
= (char *) salt
.salt_buf
;
6292 uint len
= salt
.salt_len
;
6294 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6300 case HASH_TYPE_NETNTLM
:
6302 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6303 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6305 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6311 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6313 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6321 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6323 uint max
= salt
.salt_len
/ 4;
6327 for (uint i
= 0; i
< max
; i
++)
6329 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6333 if (opts_type
& OPTS_TYPE_ST_HEX
)
6335 char tmp
[64] = { 0 };
6337 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6339 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6344 memcpy (ptr
, tmp
, len
);
6347 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6349 memset (ptr
+ len
, 0, memset_size
);
6351 salt
.salt_len
= len
;
6355 // some modes require special encoding
6358 uint out_buf_plain
[256] = { 0 };
6359 uint out_buf_salt
[256] = { 0 };
6361 char tmp_buf
[1024] = { 0 };
6363 char *ptr_plain
= (char *) out_buf_plain
;
6364 char *ptr_salt
= (char *) out_buf_salt
;
6366 if (hash_mode
== 22)
6368 char username
[30] = { 0 };
6370 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6372 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6374 u16
*ptr
= (u16
*) digest_buf
;
6376 tmp_buf
[ 0] = sig
[0];
6377 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6378 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6379 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6380 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6381 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6382 tmp_buf
[ 6] = sig
[1];
6383 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6384 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6385 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6386 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6387 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6388 tmp_buf
[12] = sig
[2];
6389 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6390 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6391 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6392 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6393 tmp_buf
[17] = sig
[3];
6394 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6395 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6396 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6397 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6398 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6399 tmp_buf
[23] = sig
[4];
6400 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6401 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6402 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6403 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6404 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6405 tmp_buf
[29] = sig
[5];
6407 snprintf (out_buf
, len
-1, "%s:%s",
6411 else if (hash_mode
== 23)
6413 // do not show the skyper part in output
6415 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6417 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6419 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6426 else if (hash_mode
== 101)
6428 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6430 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6431 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6432 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6433 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6434 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6436 memcpy (tmp_buf
, digest_buf
, 20);
6438 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6440 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6442 else if (hash_mode
== 111)
6444 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6446 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6447 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6448 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6449 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6450 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6452 memcpy (tmp_buf
, digest_buf
, 20);
6453 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6455 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6457 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6459 else if ((hash_mode
== 122) || (hash_mode
== 125))
6461 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6462 (char *) salt
.salt_buf
,
6469 else if (hash_mode
== 124)
6471 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6472 (char *) salt
.salt_buf
,
6479 else if (hash_mode
== 131)
6481 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6482 (char *) salt
.salt_buf
,
6490 else if (hash_mode
== 132)
6492 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6493 (char *) salt
.salt_buf
,
6500 else if (hash_mode
== 133)
6502 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6504 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6505 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6506 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6507 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6508 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6510 memcpy (tmp_buf
, digest_buf
, 20);
6512 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6514 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6516 else if (hash_mode
== 141)
6518 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6520 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6522 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6524 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6526 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6527 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6528 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6529 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6530 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6532 memcpy (tmp_buf
, digest_buf
, 20);
6534 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6538 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6540 else if (hash_mode
== 400)
6542 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6544 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6545 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6546 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6547 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6549 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6551 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6553 else if (hash_mode
== 500)
6555 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6557 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6558 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6559 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6560 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6562 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6564 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6566 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6570 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6573 else if (hash_mode
== 501)
6575 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6577 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6578 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6580 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6582 else if (hash_mode
== 1421)
6584 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6586 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6602 else if (hash_mode
== 1441)
6604 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6606 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6608 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6610 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6612 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6613 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6614 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6615 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6616 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6617 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6618 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6619 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6621 memcpy (tmp_buf
, digest_buf
, 32);
6623 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6627 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6629 else if (hash_mode
== 1500)
6631 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6632 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6633 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6634 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6635 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6637 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6639 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6641 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6642 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6644 memcpy (tmp_buf
, digest_buf
, 8);
6646 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6648 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6652 else if (hash_mode
== 1600)
6654 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6656 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6657 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6658 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6659 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6661 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6663 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6665 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6669 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6672 else if (hash_mode
== 1711)
6674 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6676 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6677 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6678 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6679 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6680 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6681 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6682 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6683 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6685 memcpy (tmp_buf
, digest_buf
, 64);
6686 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6688 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6690 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6692 else if (hash_mode
== 1722)
6694 uint
*ptr
= digest_buf
;
6696 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6697 (unsigned char *) salt
.salt_buf
,
6707 else if (hash_mode
== 1731)
6709 uint
*ptr
= digest_buf
;
6711 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6712 (unsigned char *) salt
.salt_buf
,
6722 else if (hash_mode
== 1800)
6726 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6727 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6728 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6729 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6730 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6731 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6732 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6733 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6735 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6737 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6739 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6743 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6746 else if (hash_mode
== 2100)
6750 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6752 salt
.salt_iter
+ 1);
6754 uint signature_len
= strlen (out_buf
);
6756 pos
+= signature_len
;
6757 len
-= signature_len
;
6759 char *salt_ptr
= (char *) salt
.salt_buf
;
6761 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6763 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6764 byte_swap_32 (digest_buf
[0]),
6765 byte_swap_32 (digest_buf
[1]),
6766 byte_swap_32 (digest_buf
[2]),
6767 byte_swap_32 (digest_buf
[3]));
6769 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6771 memcpy (tmp_buf
, digest_buf
, 16);
6773 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6775 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6776 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6777 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6778 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6780 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6781 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6782 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6783 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6785 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6786 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6787 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6788 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6790 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6791 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6792 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6793 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6795 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6796 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6797 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6798 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6802 else if (hash_mode
== 2500)
6804 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6806 wpa_t
*wpa
= &wpas
[salt_pos
];
6808 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6809 (char *) salt
.salt_buf
,
6823 else if (hash_mode
== 4400)
6825 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6826 byte_swap_32 (digest_buf
[0]),
6827 byte_swap_32 (digest_buf
[1]),
6828 byte_swap_32 (digest_buf
[2]),
6829 byte_swap_32 (digest_buf
[3]));
6831 else if (hash_mode
== 4700)
6833 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6834 byte_swap_32 (digest_buf
[0]),
6835 byte_swap_32 (digest_buf
[1]),
6836 byte_swap_32 (digest_buf
[2]),
6837 byte_swap_32 (digest_buf
[3]),
6838 byte_swap_32 (digest_buf
[4]));
6840 else if (hash_mode
== 4800)
6842 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6844 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6849 byte_swap_32 (salt
.salt_buf
[0]),
6850 byte_swap_32 (salt
.salt_buf
[1]),
6851 byte_swap_32 (salt
.salt_buf
[2]),
6852 byte_swap_32 (salt
.salt_buf
[3]),
6855 else if (hash_mode
== 4900)
6857 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6858 byte_swap_32 (digest_buf
[0]),
6859 byte_swap_32 (digest_buf
[1]),
6860 byte_swap_32 (digest_buf
[2]),
6861 byte_swap_32 (digest_buf
[3]),
6862 byte_swap_32 (digest_buf
[4]));
6864 else if (hash_mode
== 5100)
6866 snprintf (out_buf
, len
-1, "%08x%08x",
6870 else if (hash_mode
== 5200)
6872 snprintf (out_buf
, len
-1, "%s", hashfile
);
6874 else if (hash_mode
== 5300)
6876 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6878 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6880 int buf_len
= len
-1;
6884 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6886 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6888 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6890 snprintf (out_buf
, buf_len
, ":");
6896 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6904 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6906 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6908 if ((i
== 0) || (i
== 5))
6910 snprintf (out_buf
, buf_len
, ":");
6916 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6924 for (uint i
= 0; i
< 4; i
++)
6928 snprintf (out_buf
, buf_len
, ":");
6934 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6940 else if (hash_mode
== 5400)
6942 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6944 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6946 int buf_len
= len
-1;
6950 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6952 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6954 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6956 snprintf (out_buf
, buf_len
, ":");
6962 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6970 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6972 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6974 if ((i
== 0) || (i
== 5))
6976 snprintf (out_buf
, buf_len
, ":");
6982 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6990 for (uint i
= 0; i
< 5; i
++)
6994 snprintf (out_buf
, buf_len
, ":");
7000 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7006 else if (hash_mode
== 5500)
7008 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7010 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7012 char user_buf
[64] = { 0 };
7013 char domain_buf
[64] = { 0 };
7014 char srvchall_buf
[1024] = { 0 };
7015 char clichall_buf
[1024] = { 0 };
7017 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7019 char *ptr
= (char *) netntlm
->userdomain_buf
;
7021 user_buf
[i
] = ptr
[j
];
7024 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7026 char *ptr
= (char *) netntlm
->userdomain_buf
;
7028 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7031 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7033 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7035 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7038 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7040 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7042 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7045 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7053 byte_swap_32 (salt
.salt_buf_pc
[0]),
7054 byte_swap_32 (salt
.salt_buf_pc
[1]),
7057 else if (hash_mode
== 5600)
7059 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7061 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7063 char user_buf
[64] = { 0 };
7064 char domain_buf
[64] = { 0 };
7065 char srvchall_buf
[1024] = { 0 };
7066 char clichall_buf
[1024] = { 0 };
7068 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7070 char *ptr
= (char *) netntlm
->userdomain_buf
;
7072 user_buf
[i
] = ptr
[j
];
7075 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7077 char *ptr
= (char *) netntlm
->userdomain_buf
;
7079 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7082 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7084 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7086 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7089 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7091 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7093 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7096 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7106 else if (hash_mode
== 5700)
7108 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7110 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7111 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7112 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7113 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7114 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7115 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7116 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7117 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7119 memcpy (tmp_buf
, digest_buf
, 32);
7121 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7125 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7127 else if (hash_mode
== 5800)
7129 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7130 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7131 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7132 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7133 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7135 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7142 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7144 snprintf (out_buf
, len
-1, "%s", hashfile
);
7146 else if (hash_mode
== 6300)
7148 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7150 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7151 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7152 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7153 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7155 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7157 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7159 else if (hash_mode
== 6400)
7161 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7163 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7165 else if (hash_mode
== 6500)
7167 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7169 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7171 else if (hash_mode
== 6600)
7173 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7175 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7177 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7178 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7180 uint buf_len
= len
- 1;
7182 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7185 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7187 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7192 else if (hash_mode
== 6700)
7194 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7196 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7198 else if (hash_mode
== 6800)
7200 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7202 else if (hash_mode
== 7100)
7204 uint
*ptr
= digest_buf
;
7206 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7208 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7210 uint esalt
[8] = { 0 };
7212 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7213 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7214 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7215 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7216 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7217 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7218 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7219 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7221 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",
7222 SIGNATURE_SHA512OSX
,
7224 esalt
[ 0], esalt
[ 1],
7225 esalt
[ 2], esalt
[ 3],
7226 esalt
[ 4], esalt
[ 5],
7227 esalt
[ 6], esalt
[ 7],
7235 ptr
[15], ptr
[14]);
7237 else if (hash_mode
== 7200)
7239 uint
*ptr
= digest_buf
;
7241 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7243 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7247 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7249 len_used
= strlen (out_buf
);
7251 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7253 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7255 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7258 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",
7266 ptr
[15], ptr
[14]);
7268 else if (hash_mode
== 7300)
7270 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7272 rakp_t
*rakp
= &rakps
[salt_pos
];
7274 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7276 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7279 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7286 else if (hash_mode
== 7400)
7288 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7290 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7291 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7292 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7293 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7294 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7295 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7296 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7297 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7299 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7301 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7303 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7307 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7310 else if (hash_mode
== 7500)
7312 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7314 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7316 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7317 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7319 char data
[128] = { 0 };
7321 char *ptr_data
= data
;
7323 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7325 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7328 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7330 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7335 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7337 (char *) krb5pa
->user
,
7338 (char *) krb5pa
->realm
,
7339 (char *) krb5pa
->salt
,
7342 else if (hash_mode
== 7700)
7344 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7345 (char *) salt
.salt_buf
,
7349 else if (hash_mode
== 7800)
7351 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7352 (char *) salt
.salt_buf
,
7359 else if (hash_mode
== 7900)
7361 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7365 char *tmp
= (char *) salt
.salt_buf_pc
;
7367 ptr_plain
[42] = tmp
[0];
7373 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7375 else if (hash_mode
== 8000)
7377 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7378 (unsigned char *) salt
.salt_buf
,
7388 else if (hash_mode
== 8100)
7390 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7391 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7393 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7394 (unsigned char *) salt
.salt_buf
,
7401 else if (hash_mode
== 8200)
7403 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7405 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7407 char data_buf
[4096] = { 0 };
7409 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7411 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7414 data_buf
[cloudkey
->data_len
* 2] = 0;
7416 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7417 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7418 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7419 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7420 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7421 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7422 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7423 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7425 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7426 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7427 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7428 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7430 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7446 else if (hash_mode
== 8300)
7448 char digest_buf_c
[34] = { 0 };
7450 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7451 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7452 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7453 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7454 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7456 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7458 digest_buf_c
[32] = 0;
7462 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7464 char domain_buf_c
[33] = { 0 };
7466 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7468 for (uint i
= 0; i
< salt_pc_len
; i
++)
7470 const char next
= domain_buf_c
[i
];
7472 domain_buf_c
[i
] = '.';
7477 domain_buf_c
[salt_pc_len
] = 0;
7481 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7483 else if (hash_mode
== 8500)
7485 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7487 else if (hash_mode
== 2612)
7489 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7491 (char *) salt
.salt_buf
,
7497 else if (hash_mode
== 3711)
7499 char *salt_ptr
= (char *) salt
.salt_buf
;
7501 salt_ptr
[salt
.salt_len
- 1] = 0;
7503 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7504 SIGNATURE_MEDIAWIKI_B
,
7511 else if (hash_mode
== 8800)
7513 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7515 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7517 char tmp
[3073] = { 0 };
7519 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7521 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7526 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7527 SIGNATURE_ANDROIDFDE
,
7528 byte_swap_32 (salt
.salt_buf
[0]),
7529 byte_swap_32 (salt
.salt_buf
[1]),
7530 byte_swap_32 (salt
.salt_buf
[2]),
7531 byte_swap_32 (salt
.salt_buf
[3]),
7532 byte_swap_32 (digest_buf
[0]),
7533 byte_swap_32 (digest_buf
[1]),
7534 byte_swap_32 (digest_buf
[2]),
7535 byte_swap_32 (digest_buf
[3]),
7538 else if (hash_mode
== 8900)
7540 uint N
= salt
.scrypt_N
;
7541 uint r
= salt
.scrypt_r
;
7542 uint p
= salt
.scrypt_p
;
7544 char base64_salt
[32] = { 0 };
7546 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7548 memset (tmp_buf
, 0, 46);
7550 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7551 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7552 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7553 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7554 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7555 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7556 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7557 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7558 digest_buf
[8] = 0; // needed for base64_encode ()
7560 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7562 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7570 else if (hash_mode
== 9000)
7572 snprintf (out_buf
, len
-1, "%s", hashfile
);
7574 else if (hash_mode
== 9200)
7578 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7580 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7582 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7586 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7587 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7588 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7589 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7590 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7591 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7592 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7593 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7594 digest_buf
[8] = 0; // needed for base64_encode ()
7596 char tmp_buf
[64] = { 0 };
7598 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7599 tmp_buf
[43] = 0; // cut it here
7603 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7605 else if (hash_mode
== 9300)
7607 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7608 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7609 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7610 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7611 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7612 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7613 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7614 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7615 digest_buf
[8] = 0; // needed for base64_encode ()
7617 char tmp_buf
[64] = { 0 };
7619 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7620 tmp_buf
[43] = 0; // cut it here
7622 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7624 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7626 else if (hash_mode
== 9400)
7628 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7630 office2007_t
*office2007
= &office2007s
[salt_pos
];
7632 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7633 SIGNATURE_OFFICE2007
,
7636 office2007
->keySize
,
7642 office2007
->encryptedVerifier
[0],
7643 office2007
->encryptedVerifier
[1],
7644 office2007
->encryptedVerifier
[2],
7645 office2007
->encryptedVerifier
[3],
7646 office2007
->encryptedVerifierHash
[0],
7647 office2007
->encryptedVerifierHash
[1],
7648 office2007
->encryptedVerifierHash
[2],
7649 office2007
->encryptedVerifierHash
[3],
7650 office2007
->encryptedVerifierHash
[4]);
7652 else if (hash_mode
== 9500)
7654 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7656 office2010_t
*office2010
= &office2010s
[salt_pos
];
7658 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,
7664 office2010
->encryptedVerifier
[0],
7665 office2010
->encryptedVerifier
[1],
7666 office2010
->encryptedVerifier
[2],
7667 office2010
->encryptedVerifier
[3],
7668 office2010
->encryptedVerifierHash
[0],
7669 office2010
->encryptedVerifierHash
[1],
7670 office2010
->encryptedVerifierHash
[2],
7671 office2010
->encryptedVerifierHash
[3],
7672 office2010
->encryptedVerifierHash
[4],
7673 office2010
->encryptedVerifierHash
[5],
7674 office2010
->encryptedVerifierHash
[6],
7675 office2010
->encryptedVerifierHash
[7]);
7677 else if (hash_mode
== 9600)
7679 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7681 office2013_t
*office2013
= &office2013s
[salt_pos
];
7683 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,
7689 office2013
->encryptedVerifier
[0],
7690 office2013
->encryptedVerifier
[1],
7691 office2013
->encryptedVerifier
[2],
7692 office2013
->encryptedVerifier
[3],
7693 office2013
->encryptedVerifierHash
[0],
7694 office2013
->encryptedVerifierHash
[1],
7695 office2013
->encryptedVerifierHash
[2],
7696 office2013
->encryptedVerifierHash
[3],
7697 office2013
->encryptedVerifierHash
[4],
7698 office2013
->encryptedVerifierHash
[5],
7699 office2013
->encryptedVerifierHash
[6],
7700 office2013
->encryptedVerifierHash
[7]);
7702 else if (hash_mode
== 9700)
7704 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7706 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7708 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7709 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7710 byte_swap_32 (salt
.salt_buf
[0]),
7711 byte_swap_32 (salt
.salt_buf
[1]),
7712 byte_swap_32 (salt
.salt_buf
[2]),
7713 byte_swap_32 (salt
.salt_buf
[3]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7720 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7721 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7723 else if (hash_mode
== 9710)
7725 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7727 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7729 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7730 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7731 byte_swap_32 (salt
.salt_buf
[0]),
7732 byte_swap_32 (salt
.salt_buf
[1]),
7733 byte_swap_32 (salt
.salt_buf
[2]),
7734 byte_swap_32 (salt
.salt_buf
[3]),
7735 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7736 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7737 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7738 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7739 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7742 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7744 else if (hash_mode
== 9720)
7746 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7748 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7750 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7752 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7753 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7754 byte_swap_32 (salt
.salt_buf
[0]),
7755 byte_swap_32 (salt
.salt_buf
[1]),
7756 byte_swap_32 (salt
.salt_buf
[2]),
7757 byte_swap_32 (salt
.salt_buf
[3]),
7758 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7759 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7760 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7761 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7762 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7765 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7772 else if (hash_mode
== 9800)
7774 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7776 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7778 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7779 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7792 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7794 else if (hash_mode
== 9810)
7796 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7798 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7800 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7801 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7806 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7807 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7808 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7809 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7810 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7811 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7814 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7816 else if (hash_mode
== 9820)
7818 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7820 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7822 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7824 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7825 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7830 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7831 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7832 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7833 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7838 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7845 else if (hash_mode
== 10000)
7849 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7851 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7853 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7857 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7858 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7859 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7860 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7861 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7862 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7863 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7864 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7865 digest_buf
[8] = 0; // needed for base64_encode ()
7867 char tmp_buf
[64] = { 0 };
7869 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7873 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7875 else if (hash_mode
== 10100)
7877 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7882 byte_swap_32 (salt
.salt_buf
[0]),
7883 byte_swap_32 (salt
.salt_buf
[1]),
7884 byte_swap_32 (salt
.salt_buf
[2]),
7885 byte_swap_32 (salt
.salt_buf
[3]));
7887 else if (hash_mode
== 10200)
7889 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7891 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7895 char challenge
[100] = { 0 };
7897 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7901 char tmp_buf
[100] = { 0 };
7903 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7904 (char *) cram_md5
->user
,
7910 char response
[100] = { 0 };
7912 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7914 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7916 else if (hash_mode
== 10300)
7918 char tmp_buf
[100] = { 0 };
7920 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7921 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7923 uint tmp_len
= 20 + salt
.salt_len
;
7927 char base64_encoded
[100] = { 0 };
7929 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7931 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7933 else if (hash_mode
== 10400)
7935 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7937 pdf_t
*pdf
= &pdfs
[salt_pos
];
7939 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",
7947 byte_swap_32 (pdf
->id_buf
[0]),
7948 byte_swap_32 (pdf
->id_buf
[1]),
7949 byte_swap_32 (pdf
->id_buf
[2]),
7950 byte_swap_32 (pdf
->id_buf
[3]),
7952 byte_swap_32 (pdf
->u_buf
[0]),
7953 byte_swap_32 (pdf
->u_buf
[1]),
7954 byte_swap_32 (pdf
->u_buf
[2]),
7955 byte_swap_32 (pdf
->u_buf
[3]),
7956 byte_swap_32 (pdf
->u_buf
[4]),
7957 byte_swap_32 (pdf
->u_buf
[5]),
7958 byte_swap_32 (pdf
->u_buf
[6]),
7959 byte_swap_32 (pdf
->u_buf
[7]),
7961 byte_swap_32 (pdf
->o_buf
[0]),
7962 byte_swap_32 (pdf
->o_buf
[1]),
7963 byte_swap_32 (pdf
->o_buf
[2]),
7964 byte_swap_32 (pdf
->o_buf
[3]),
7965 byte_swap_32 (pdf
->o_buf
[4]),
7966 byte_swap_32 (pdf
->o_buf
[5]),
7967 byte_swap_32 (pdf
->o_buf
[6]),
7968 byte_swap_32 (pdf
->o_buf
[7])
7971 else if (hash_mode
== 10410)
7973 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7975 pdf_t
*pdf
= &pdfs
[salt_pos
];
7977 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",
7985 byte_swap_32 (pdf
->id_buf
[0]),
7986 byte_swap_32 (pdf
->id_buf
[1]),
7987 byte_swap_32 (pdf
->id_buf
[2]),
7988 byte_swap_32 (pdf
->id_buf
[3]),
7990 byte_swap_32 (pdf
->u_buf
[0]),
7991 byte_swap_32 (pdf
->u_buf
[1]),
7992 byte_swap_32 (pdf
->u_buf
[2]),
7993 byte_swap_32 (pdf
->u_buf
[3]),
7994 byte_swap_32 (pdf
->u_buf
[4]),
7995 byte_swap_32 (pdf
->u_buf
[5]),
7996 byte_swap_32 (pdf
->u_buf
[6]),
7997 byte_swap_32 (pdf
->u_buf
[7]),
7999 byte_swap_32 (pdf
->o_buf
[0]),
8000 byte_swap_32 (pdf
->o_buf
[1]),
8001 byte_swap_32 (pdf
->o_buf
[2]),
8002 byte_swap_32 (pdf
->o_buf
[3]),
8003 byte_swap_32 (pdf
->o_buf
[4]),
8004 byte_swap_32 (pdf
->o_buf
[5]),
8005 byte_swap_32 (pdf
->o_buf
[6]),
8006 byte_swap_32 (pdf
->o_buf
[7])
8009 else if (hash_mode
== 10420)
8011 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8013 pdf_t
*pdf
= &pdfs
[salt_pos
];
8015 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8017 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",
8025 byte_swap_32 (pdf
->id_buf
[0]),
8026 byte_swap_32 (pdf
->id_buf
[1]),
8027 byte_swap_32 (pdf
->id_buf
[2]),
8028 byte_swap_32 (pdf
->id_buf
[3]),
8030 byte_swap_32 (pdf
->u_buf
[0]),
8031 byte_swap_32 (pdf
->u_buf
[1]),
8032 byte_swap_32 (pdf
->u_buf
[2]),
8033 byte_swap_32 (pdf
->u_buf
[3]),
8034 byte_swap_32 (pdf
->u_buf
[4]),
8035 byte_swap_32 (pdf
->u_buf
[5]),
8036 byte_swap_32 (pdf
->u_buf
[6]),
8037 byte_swap_32 (pdf
->u_buf
[7]),
8039 byte_swap_32 (pdf
->o_buf
[0]),
8040 byte_swap_32 (pdf
->o_buf
[1]),
8041 byte_swap_32 (pdf
->o_buf
[2]),
8042 byte_swap_32 (pdf
->o_buf
[3]),
8043 byte_swap_32 (pdf
->o_buf
[4]),
8044 byte_swap_32 (pdf
->o_buf
[5]),
8045 byte_swap_32 (pdf
->o_buf
[6]),
8046 byte_swap_32 (pdf
->o_buf
[7]),
8054 else if (hash_mode
== 10500)
8056 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8058 pdf_t
*pdf
= &pdfs
[salt_pos
];
8060 if (pdf
->id_len
== 32)
8062 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",
8070 byte_swap_32 (pdf
->id_buf
[0]),
8071 byte_swap_32 (pdf
->id_buf
[1]),
8072 byte_swap_32 (pdf
->id_buf
[2]),
8073 byte_swap_32 (pdf
->id_buf
[3]),
8074 byte_swap_32 (pdf
->id_buf
[4]),
8075 byte_swap_32 (pdf
->id_buf
[5]),
8076 byte_swap_32 (pdf
->id_buf
[6]),
8077 byte_swap_32 (pdf
->id_buf
[7]),
8079 byte_swap_32 (pdf
->u_buf
[0]),
8080 byte_swap_32 (pdf
->u_buf
[1]),
8081 byte_swap_32 (pdf
->u_buf
[2]),
8082 byte_swap_32 (pdf
->u_buf
[3]),
8083 byte_swap_32 (pdf
->u_buf
[4]),
8084 byte_swap_32 (pdf
->u_buf
[5]),
8085 byte_swap_32 (pdf
->u_buf
[6]),
8086 byte_swap_32 (pdf
->u_buf
[7]),
8088 byte_swap_32 (pdf
->o_buf
[0]),
8089 byte_swap_32 (pdf
->o_buf
[1]),
8090 byte_swap_32 (pdf
->o_buf
[2]),
8091 byte_swap_32 (pdf
->o_buf
[3]),
8092 byte_swap_32 (pdf
->o_buf
[4]),
8093 byte_swap_32 (pdf
->o_buf
[5]),
8094 byte_swap_32 (pdf
->o_buf
[6]),
8095 byte_swap_32 (pdf
->o_buf
[7])
8100 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",
8108 byte_swap_32 (pdf
->id_buf
[0]),
8109 byte_swap_32 (pdf
->id_buf
[1]),
8110 byte_swap_32 (pdf
->id_buf
[2]),
8111 byte_swap_32 (pdf
->id_buf
[3]),
8113 byte_swap_32 (pdf
->u_buf
[0]),
8114 byte_swap_32 (pdf
->u_buf
[1]),
8115 byte_swap_32 (pdf
->u_buf
[2]),
8116 byte_swap_32 (pdf
->u_buf
[3]),
8117 byte_swap_32 (pdf
->u_buf
[4]),
8118 byte_swap_32 (pdf
->u_buf
[5]),
8119 byte_swap_32 (pdf
->u_buf
[6]),
8120 byte_swap_32 (pdf
->u_buf
[7]),
8122 byte_swap_32 (pdf
->o_buf
[0]),
8123 byte_swap_32 (pdf
->o_buf
[1]),
8124 byte_swap_32 (pdf
->o_buf
[2]),
8125 byte_swap_32 (pdf
->o_buf
[3]),
8126 byte_swap_32 (pdf
->o_buf
[4]),
8127 byte_swap_32 (pdf
->o_buf
[5]),
8128 byte_swap_32 (pdf
->o_buf
[6]),
8129 byte_swap_32 (pdf
->o_buf
[7])
8133 else if (hash_mode
== 10600)
8135 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8137 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8138 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8140 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8142 else if (hash_mode
== 10700)
8144 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8146 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8147 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8149 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8151 else if (hash_mode
== 10900)
8153 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8155 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8156 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8158 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8160 else if (hash_mode
== 11100)
8162 u32 salt_challenge
= salt
.salt_buf
[0];
8164 salt_challenge
= byte_swap_32 (salt_challenge
);
8166 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8168 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8169 SIGNATURE_POSTGRESQL_AUTH
,
8177 else if (hash_mode
== 11200)
8179 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8180 SIGNATURE_MYSQL_AUTH
,
8181 (unsigned char *) salt
.salt_buf
,
8188 else if (hash_mode
== 11300)
8190 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8192 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8194 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8195 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8196 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8198 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8199 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8200 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8202 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8204 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8206 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8209 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8211 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8213 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8216 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8218 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8220 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8223 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8224 SIGNATURE_BITCOIN_WALLET
,
8228 (unsigned char *) salt
.salt_buf
,
8236 free (cry_master_buf
);
8238 free (public_key_buf
);
8240 else if (hash_mode
== 11400)
8242 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8244 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8245 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8247 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8249 else if (hash_mode
== 11600)
8251 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8253 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8255 const uint data_len
= seven_zip
->data_len
;
8257 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8259 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8261 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8263 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8266 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8267 SIGNATURE_SEVEN_ZIP
,
8271 (char *) seven_zip
->salt_buf
,
8273 seven_zip
->iv_buf
[0],
8274 seven_zip
->iv_buf
[1],
8275 seven_zip
->iv_buf
[2],
8276 seven_zip
->iv_buf
[3],
8278 seven_zip
->data_len
,
8279 seven_zip
->unpack_size
,
8284 else if (hash_mode
== 11700)
8286 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8296 else if (hash_mode
== 11800)
8298 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8316 else if (hash_mode
== 11900)
8318 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8320 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8321 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8323 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8325 else if (hash_mode
== 12000)
8327 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8329 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8330 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8332 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8334 else if (hash_mode
== 12100)
8336 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8338 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8339 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8341 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8343 else if (hash_mode
== 12200)
8345 uint
*ptr_digest
= digest_buf
;
8346 uint
*ptr_salt
= salt
.salt_buf
;
8348 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8355 else if (hash_mode
== 12300)
8357 uint
*ptr_digest
= digest_buf
;
8358 uint
*ptr_salt
= salt
.salt_buf
;
8360 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",
8361 ptr_digest
[ 0], ptr_digest
[ 1],
8362 ptr_digest
[ 2], ptr_digest
[ 3],
8363 ptr_digest
[ 4], ptr_digest
[ 5],
8364 ptr_digest
[ 6], ptr_digest
[ 7],
8365 ptr_digest
[ 8], ptr_digest
[ 9],
8366 ptr_digest
[10], ptr_digest
[11],
8367 ptr_digest
[12], ptr_digest
[13],
8368 ptr_digest
[14], ptr_digest
[15],
8374 else if (hash_mode
== 12400)
8376 // encode iteration count
8378 char salt_iter
[5] = { 0 };
8380 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8381 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8382 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8383 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8388 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8389 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8390 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8391 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8396 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8398 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8399 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8401 memcpy (tmp_buf
, digest_buf
, 8);
8403 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8407 // fill the resulting buffer
8409 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8411 else if (hash_mode
== 12500)
8413 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8415 byte_swap_32 (salt
.salt_buf
[0]),
8416 byte_swap_32 (salt
.salt_buf
[1]),
8422 else if (hash_mode
== 12600)
8424 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8425 digest_buf
[0] + salt
.salt_buf_pc
[0],
8426 digest_buf
[1] + salt
.salt_buf_pc
[1],
8427 digest_buf
[2] + salt
.salt_buf_pc
[2],
8428 digest_buf
[3] + salt
.salt_buf_pc
[3],
8429 digest_buf
[4] + salt
.salt_buf_pc
[4],
8430 digest_buf
[5] + salt
.salt_buf_pc
[5],
8431 digest_buf
[6] + salt
.salt_buf_pc
[6],
8432 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8434 else if (hash_mode
== 12700)
8436 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8438 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8439 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8441 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8443 else if (hash_mode
== 12800)
8445 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8447 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",
8460 byte_swap_32 (digest_buf
[0]),
8461 byte_swap_32 (digest_buf
[1]),
8462 byte_swap_32 (digest_buf
[2]),
8463 byte_swap_32 (digest_buf
[3]),
8464 byte_swap_32 (digest_buf
[4]),
8465 byte_swap_32 (digest_buf
[5]),
8466 byte_swap_32 (digest_buf
[6]),
8467 byte_swap_32 (digest_buf
[7])
8470 else if (hash_mode
== 12900)
8472 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",
8481 byte_swap_32 (digest_buf
[0]),
8482 byte_swap_32 (digest_buf
[1]),
8483 byte_swap_32 (digest_buf
[2]),
8484 byte_swap_32 (digest_buf
[3]),
8485 byte_swap_32 (digest_buf
[4]),
8486 byte_swap_32 (digest_buf
[5]),
8487 byte_swap_32 (digest_buf
[6]),
8488 byte_swap_32 (digest_buf
[7]),
8495 else if (hash_mode
== 13000)
8497 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8499 rar5_t
*rar5
= &rar5s
[salt_pos
];
8501 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8511 byte_swap_32 (digest_buf
[0]),
8512 byte_swap_32 (digest_buf
[1])
8515 else if (hash_mode
== 13100)
8517 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8519 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8521 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8522 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8524 char data
[2560 * 4 * 2] = { 0 };
8526 char *ptr_data
= data
;
8528 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8529 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8534 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8535 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8537 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8539 (char *) krb5tgs
->account_info
,
8543 else if (hash_mode
== 13200)
8545 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8559 else if (hash_mode
== 13300)
8561 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8562 SIGNATURE_AXCRYPT_SHA1
,
8568 else if (hash_mode
== 13400)
8570 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8572 keepass_t
*keepass
= &keepasss
[salt_pos
];
8574 u32 version
= (u32
) keepass
->version
;
8575 u32 rounds
= salt
.salt_iter
;
8576 u32 algorithm
= (u32
) keepass
->algorithm
;
8577 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8579 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8580 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8581 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8582 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8583 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8585 /* specific to version 1 */
8589 /* specific to version 2 */
8590 u32 expected_bytes_len
;
8591 u32
*ptr_expected_bytes
;
8593 u32 final_random_seed_len
;
8594 u32 transf_random_seed_len
;
8596 u32 contents_hash_len
;
8598 transf_random_seed_len
= 8;
8600 contents_hash_len
= 8;
8601 final_random_seed_len
= 8;
8604 final_random_seed_len
= 4;
8606 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8612 char *ptr_data
= out_buf
;
8614 ptr_data
+= strlen(out_buf
);
8619 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8620 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8625 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8626 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8631 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8632 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8639 contents_len
= (u32
) keepass
->contents_len
;
8640 ptr_contents
= (u32
*) keepass
->contents
;
8642 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8643 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8655 char ptr_contents_len
[10] = { 0 };
8657 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8659 sprintf (ptr_data
, "%d", contents_len
);
8661 ptr_data
+= strlen(ptr_contents_len
);
8666 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8667 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8669 else if (version
== 2)
8671 expected_bytes_len
= 8;
8672 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8674 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8675 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8680 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8681 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8695 sprintf (ptr_data
, "%d", keyfile_len
);
8702 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8703 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8706 else if (hash_mode
== 13500)
8708 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8710 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8712 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8714 char pstoken_tmp
[1024 + 1] = { 0 };
8716 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8718 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8720 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8723 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8731 else if (hash_mode
== 13600)
8733 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8735 zip2_t
*zip2
= &zip2s
[salt_pos
];
8737 const u32 salt_len
= zip2
->salt_len
;
8739 char salt_tmp
[32 + 1] = { 0 };
8741 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8743 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8745 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8748 const u32 data_len
= zip2
->data_len
;
8750 char data_tmp
[8192 + 1] = { 0 };
8752 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8754 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8756 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8759 const u32 auth_len
= zip2
->auth_len
;
8761 char auth_tmp
[20 + 1] = { 0 };
8763 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8765 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8767 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8770 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8771 SIGNATURE_ZIP2_START
,
8777 zip2
->compress_length
,
8780 SIGNATURE_ZIP2_STOP
);
8782 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8784 snprintf (out_buf
, len
-1, "%s", hashfile
);
8786 else if (hash_mode
== 13800)
8788 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8790 win8phone_t
*esalt
= &esalts
[salt_pos
];
8792 char buf
[256 + 1] = { 0 };
8794 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8796 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8799 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8812 if (hash_type
== HASH_TYPE_MD4
)
8814 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8820 else if (hash_type
== HASH_TYPE_MD5
)
8822 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8828 else if (hash_type
== HASH_TYPE_SHA1
)
8830 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8837 else if (hash_type
== HASH_TYPE_SHA256
)
8839 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8849 else if (hash_type
== HASH_TYPE_SHA384
)
8851 uint
*ptr
= digest_buf
;
8853 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8861 else if (hash_type
== HASH_TYPE_SHA512
)
8863 uint
*ptr
= digest_buf
;
8865 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8875 else if (hash_type
== HASH_TYPE_LM
)
8877 snprintf (out_buf
, len
-1, "%08x%08x",
8881 else if (hash_type
== HASH_TYPE_ORACLEH
)
8883 snprintf (out_buf
, len
-1, "%08X%08X",
8887 else if (hash_type
== HASH_TYPE_BCRYPT
)
8889 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8890 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8892 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8894 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8896 else if (hash_type
== HASH_TYPE_KECCAK
)
8898 uint
*ptr
= digest_buf
;
8900 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",
8928 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8930 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8932 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8939 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8941 digest_buf
[ 0] = digest_buf
[ 0];
8942 digest_buf
[ 1] = digest_buf
[ 1];
8943 digest_buf
[ 2] = digest_buf
[ 2];
8944 digest_buf
[ 3] = digest_buf
[ 3];
8945 digest_buf
[ 4] = digest_buf
[ 4];
8946 digest_buf
[ 5] = digest_buf
[ 5];
8947 digest_buf
[ 6] = digest_buf
[ 6];
8948 digest_buf
[ 7] = digest_buf
[ 7];
8949 digest_buf
[ 8] = digest_buf
[ 8];
8950 digest_buf
[ 9] = digest_buf
[ 9];
8951 digest_buf
[10] = digest_buf
[10];
8952 digest_buf
[11] = digest_buf
[11];
8953 digest_buf
[12] = digest_buf
[12];
8954 digest_buf
[13] = digest_buf
[13];
8955 digest_buf
[14] = digest_buf
[14];
8956 digest_buf
[15] = digest_buf
[15];
8958 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8976 else if (hash_type
== HASH_TYPE_GOST
)
8978 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8988 else if (hash_type
== HASH_TYPE_MYSQL
)
8990 snprintf (out_buf
, len
-1, "%08x%08x",
8994 else if (hash_type
== HASH_TYPE_LOTUS5
)
8996 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9002 else if (hash_type
== HASH_TYPE_LOTUS6
)
9004 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9005 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9006 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9007 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9009 char buf
[16] = { 0 };
9011 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9012 memcpy (buf
+ 5, digest_buf
, 9);
9016 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9018 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9021 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9023 else if (hash_type
== HASH_TYPE_LOTUS8
)
9025 char buf
[52] = { 0 };
9029 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9035 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9039 buf
[26] = salt
.salt_buf_pc
[0];
9040 buf
[27] = salt
.salt_buf_pc
[1];
9044 memcpy (buf
+ 28, digest_buf
, 8);
9046 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9050 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9052 else if (hash_type
== HASH_TYPE_CRC32
)
9054 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9058 if (salt_type
== SALT_TYPE_INTERN
)
9060 size_t pos
= strlen (out_buf
);
9062 out_buf
[pos
] = data
.separator
;
9064 char *ptr
= (char *) salt
.salt_buf
;
9066 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9068 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9072 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9074 memset (hccap
, 0, sizeof (hccap_t
));
9076 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9078 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9080 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9081 wpa_t
*wpa
= &wpas
[salt_pos
];
9083 hccap
->keyver
= wpa
->keyver
;
9085 hccap
->eapol_size
= wpa
->eapol_size
;
9087 if (wpa
->keyver
!= 1)
9089 uint eapol_tmp
[64] = { 0 };
9091 for (uint i
= 0; i
< 64; i
++)
9093 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9096 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9100 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9103 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9104 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9105 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9106 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9108 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9110 uint dgst_size
= data
.dgst_size
;
9112 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9114 if (wpa
->keyver
!= 1)
9116 uint digest_tmp
[4] = { 0 };
9118 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9119 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9120 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9121 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9123 memcpy (hccap
->keymic
, digest_tmp
, 16);
9127 memcpy (hccap
->keymic
, digest_ptr
, 16);
9131 void SuspendThreads ()
9133 if (data
.devices_status
== STATUS_RUNNING
)
9135 hc_timer_set (&data
.timer_paused
);
9137 data
.devices_status
= STATUS_PAUSED
;
9139 log_info ("Paused");
9143 void ResumeThreads ()
9145 if (data
.devices_status
== STATUS_PAUSED
)
9149 hc_timer_get (data
.timer_paused
, ms_paused
);
9151 data
.ms_paused
+= ms_paused
;
9153 data
.devices_status
= STATUS_RUNNING
;
9155 log_info ("Resumed");
9161 if (data
.devices_status
!= STATUS_RUNNING
) return;
9163 data
.devices_status
= STATUS_BYPASS
;
9165 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9168 void stop_at_checkpoint ()
9170 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9172 if (data
.devices_status
!= STATUS_RUNNING
) return;
9175 // this feature only makes sense if --restore-disable was not specified
9177 if (data
.restore_disable
== 1)
9179 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9184 // check if monitoring of Restore Point updates should be enabled or disabled
9186 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9188 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9190 // save the current restore point value
9192 data
.checkpoint_cur_words
= get_lowest_words_done ();
9194 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9198 data
.devices_status
= STATUS_RUNNING
;
9200 // reset the global value for checkpoint checks
9202 data
.checkpoint_cur_words
= 0;
9204 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9210 if (data
.devices_status
== STATUS_INIT
) return;
9211 if (data
.devices_status
== STATUS_STARTING
) return;
9213 data
.devices_status
= STATUS_ABORTED
;
9218 if (data
.devices_status
== STATUS_INIT
) return;
9219 if (data
.devices_status
== STATUS_STARTING
) return;
9221 data
.devices_status
= STATUS_QUIT
;
9224 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9226 FILE *fp
= fopen (kernel_file
, "rb");
9232 memset (&st
, 0, sizeof (st
));
9234 stat (kernel_file
, &st
);
9236 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9238 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9240 if (num_read
!= (size_t) st
.st_size
)
9242 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9249 buf
[st
.st_size
] = 0;
9251 for (int i
= 0; i
< num_devices
; i
++)
9253 kernel_lengths
[i
] = (size_t) st
.st_size
;
9255 kernel_sources
[i
] = buf
;
9260 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9268 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9270 if (binary_size
> 0)
9272 FILE *fp
= fopen (dst
, "wb");
9275 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9286 restore_data_t
*init_restore (int argc
, char **argv
)
9288 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9290 if (data
.restore_disable
== 0)
9292 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9296 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9300 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9309 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9311 int pidbin_len
= -1;
9314 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9316 FILE *fd
= fopen (pidbin
, "rb");
9320 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9322 pidbin
[pidbin_len
] = 0;
9326 char *argv0_r
= strrchr (argv
[0], '/');
9328 char *pidbin_r
= strrchr (pidbin
, '/');
9330 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9332 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9334 if (strcmp (argv0_r
, pidbin_r
) == 0)
9336 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9343 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9345 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9347 int pidbin2_len
= -1;
9349 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9350 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9352 pidbin
[pidbin_len
] = 0;
9353 pidbin2
[pidbin2_len
] = 0;
9357 if (strcmp (pidbin
, pidbin2
) == 0)
9359 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9372 if (rd
->version_bin
< RESTORE_MIN
)
9374 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9381 memset (rd
, 0, sizeof (restore_data_t
));
9383 rd
->version_bin
= VERSION_BIN
;
9386 rd
->pid
= getpid ();
9388 rd
->pid
= GetCurrentProcessId ();
9391 if (getcwd (rd
->cwd
, 255) == NULL
)
9404 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9406 FILE *fp
= fopen (eff_restore_file
, "rb");
9410 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9415 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9417 log_error ("ERROR: Can't read %s", eff_restore_file
);
9422 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9424 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9426 for (uint i
= 0; i
< rd
->argc
; i
++)
9428 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9430 log_error ("ERROR: Can't read %s", eff_restore_file
);
9435 size_t len
= strlen (buf
);
9437 if (len
) buf
[len
- 1] = 0;
9439 rd
->argv
[i
] = mystrdup (buf
);
9446 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9448 if (chdir (rd
->cwd
))
9450 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9451 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9452 " https://github.com/philsmd/analyze_hc_restore\n"
9453 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9459 u64
get_lowest_words_done ()
9463 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9465 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9467 if (device_param
->skipped
) continue;
9469 const u64 words_done
= device_param
->words_done
;
9471 if (words_done
< words_cur
) words_cur
= words_done
;
9474 // It's possible that a device's workload isn't finished right after a restore-case.
9475 // In that case, this function would return 0 and overwrite the real restore point
9476 // There's also data.words_cur which is set to rd->words_cur but it changes while
9477 // the attack is running therefore we should stick to rd->words_cur.
9478 // Note that -s influences rd->words_cur we should keep a close look on that.
9480 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9485 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9487 u64 words_cur
= get_lowest_words_done ();
9489 rd
->words_cur
= words_cur
;
9491 FILE *fp
= fopen (new_restore_file
, "wb");
9495 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9500 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9502 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9507 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9509 for (uint i
= 0; i
< rd
->argc
; i
++)
9511 fprintf (fp
, "%s", rd
->argv
[i
]);
9517 fsync (fileno (fp
));
9522 void cycle_restore ()
9524 const char *eff_restore_file
= data
.eff_restore_file
;
9525 const char *new_restore_file
= data
.new_restore_file
;
9527 restore_data_t
*rd
= data
.rd
;
9529 write_restore (new_restore_file
, rd
);
9533 memset (&st
, 0, sizeof(st
));
9535 if (stat (eff_restore_file
, &st
) == 0)
9537 if (unlink (eff_restore_file
))
9539 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9543 if (rename (new_restore_file
, eff_restore_file
))
9545 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9549 void check_checkpoint ()
9551 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9553 u64 words_cur
= get_lowest_words_done ();
9555 if (words_cur
!= data
.checkpoint_cur_words
)
9565 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9569 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9571 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9573 myfree (alias
->device_name
);
9574 myfree (alias
->alias_name
);
9577 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9579 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9581 myfree (entry
->device_name
);
9584 myfree (tuning_db
->alias_buf
);
9585 myfree (tuning_db
->entry_buf
);
9590 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9592 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9594 int num_lines
= count_lines (fp
);
9596 // a bit over-allocated
9598 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9599 tuning_db
->alias_cnt
= 0;
9601 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9602 tuning_db
->entry_cnt
= 0;
9607 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9609 FILE *fp
= fopen (tuning_db_file
, "rb");
9613 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9618 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9624 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9628 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9630 if (line_buf
== NULL
) break;
9634 const int line_len
= in_superchop (line_buf
);
9636 if (line_len
== 0) continue;
9638 if (line_buf
[0] == '#') continue;
9642 char *token_ptr
[7] = { NULL
};
9646 char *next
= strtok (line_buf
, "\t ");
9648 token_ptr
[token_cnt
] = next
;
9652 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9654 token_ptr
[token_cnt
] = next
;
9661 char *device_name
= token_ptr
[0];
9662 char *alias_name
= token_ptr
[1];
9664 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9666 alias
->device_name
= mystrdup (device_name
);
9667 alias
->alias_name
= mystrdup (alias_name
);
9669 tuning_db
->alias_cnt
++;
9671 else if (token_cnt
== 6)
9673 if ((token_ptr
[1][0] != '0') &&
9674 (token_ptr
[1][0] != '1') &&
9675 (token_ptr
[1][0] != '3') &&
9676 (token_ptr
[1][0] != '*'))
9678 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9683 if ((token_ptr
[3][0] != '1') &&
9684 (token_ptr
[3][0] != '2') &&
9685 (token_ptr
[3][0] != '4') &&
9686 (token_ptr
[3][0] != '8') &&
9687 (token_ptr
[3][0] != 'N'))
9689 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9694 char *device_name
= token_ptr
[0];
9696 int attack_mode
= -1;
9698 int vector_width
= -1;
9699 int kernel_accel
= -1;
9700 int kernel_loops
= -1;
9702 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9703 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9704 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9706 if (token_ptr
[4][0] != 'A')
9708 kernel_accel
= atoi (token_ptr
[4]);
9710 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9712 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9722 if (token_ptr
[5][0] != 'A')
9724 kernel_loops
= atoi (token_ptr
[5]);
9726 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9728 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9738 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9740 entry
->device_name
= mystrdup (device_name
);
9741 entry
->attack_mode
= attack_mode
;
9742 entry
->hash_type
= hash_type
;
9743 entry
->vector_width
= vector_width
;
9744 entry
->kernel_accel
= kernel_accel
;
9745 entry
->kernel_loops
= kernel_loops
;
9747 tuning_db
->entry_cnt
++;
9751 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9761 // todo: print loaded 'cnt' message
9763 // sort the database
9765 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9766 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9771 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9773 static tuning_db_entry_t s
;
9775 // first we need to convert all spaces in the device_name to underscore
9777 char *device_name_nospace
= strdup (device_param
->device_name
);
9779 int device_name_length
= strlen (device_name_nospace
);
9783 for (i
= 0; i
< device_name_length
; i
++)
9785 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9788 // find out if there's an alias configured
9790 tuning_db_alias_t a
;
9792 a
.device_name
= device_name_nospace
;
9794 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
);
9796 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9798 // attack-mode 6 and 7 are attack-mode 1 basically
9800 if (attack_mode
== 6) attack_mode
= 1;
9801 if (attack_mode
== 7) attack_mode
= 1;
9803 // bsearch is not ideal but fast enough
9805 s
.device_name
= device_name_nospace
;
9806 s
.attack_mode
= attack_mode
;
9807 s
.hash_type
= hash_type
;
9809 tuning_db_entry_t
*entry
= NULL
;
9811 // this will produce all 2^3 combinations required
9813 for (i
= 0; i
< 8; i
++)
9815 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9816 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9817 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9819 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9821 if (entry
!= NULL
) break;
9823 // in non-wildcard mode do some additional checks:
9827 // in case we have an alias-name
9829 if (alias_name
!= NULL
)
9831 s
.device_name
= alias_name
;
9833 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9835 if (entry
!= NULL
) break;
9838 // or by device type
9840 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9842 s
.device_name
= "DEVICE_TYPE_CPU";
9844 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9846 s
.device_name
= "DEVICE_TYPE_GPU";
9848 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9850 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9853 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9855 if (entry
!= NULL
) break;
9859 // free converted device_name
9861 myfree (device_name_nospace
);
9870 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9872 u8 tmp
[256] = { 0 };
9874 if (salt_len
> sizeof (tmp
))
9879 memcpy (tmp
, in
, salt_len
);
9881 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9883 if ((salt_len
% 2) == 0)
9885 u32 new_salt_len
= salt_len
/ 2;
9887 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9892 tmp
[i
] = hex_convert (p1
) << 0;
9893 tmp
[i
] |= hex_convert (p0
) << 4;
9896 salt_len
= new_salt_len
;
9903 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9905 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9908 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9910 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9914 u32
*tmp_uint
= (u32
*) tmp
;
9916 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9917 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9918 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9919 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9920 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9921 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9922 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9923 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9924 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9925 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9927 salt_len
= salt_len
* 2;
9935 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9937 lowercase (tmp
, salt_len
);
9940 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9942 uppercase (tmp
, salt_len
);
9947 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9952 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9957 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9959 u32
*tmp_uint
= (uint
*) tmp
;
9965 for (u32 i
= 0; i
< max
; i
++)
9967 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9970 // Important: we may need to increase the length of memcpy since
9971 // we don't want to "loose" some swapped bytes (could happen if
9972 // they do not perfectly fit in the 4-byte blocks)
9973 // Memcpy does always copy the bytes in the BE order, but since
9974 // we swapped them, some important bytes could be in positions
9975 // we normally skip with the original len
9977 if (len
% 4) len
+= 4 - (len
% 4);
9980 memcpy (out
, tmp
, len
);
9985 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9987 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9989 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9991 u32
*digest
= (u32
*) hash_buf
->digest
;
9993 salt_t
*salt
= hash_buf
->salt
;
9995 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9997 char *iter_pos
= input_buf
+ 4;
9999 salt
->salt_iter
= 1 << atoi (iter_pos
);
10001 char *salt_pos
= strchr (iter_pos
, '$');
10003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10007 uint salt_len
= 16;
10009 salt
->salt_len
= salt_len
;
10011 u8 tmp_buf
[100] = { 0 };
10013 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10017 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10019 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10020 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10021 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10022 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10024 char *hash_pos
= salt_pos
+ 22;
10026 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10028 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10030 memcpy (digest
, tmp_buf
, 24);
10032 digest
[0] = byte_swap_32 (digest
[0]);
10033 digest
[1] = byte_swap_32 (digest
[1]);
10034 digest
[2] = byte_swap_32 (digest
[2]);
10035 digest
[3] = byte_swap_32 (digest
[3]);
10036 digest
[4] = byte_swap_32 (digest
[4]);
10037 digest
[5] = byte_swap_32 (digest
[5]);
10039 digest
[5] &= ~0xff; // its just 23 not 24 !
10041 return (PARSER_OK
);
10044 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10046 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10048 u32
*digest
= (u32
*) hash_buf
->digest
;
10050 u8 tmp_buf
[100] = { 0 };
10052 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10054 memcpy (digest
, tmp_buf
, 32);
10056 digest
[0] = byte_swap_32 (digest
[0]);
10057 digest
[1] = byte_swap_32 (digest
[1]);
10058 digest
[2] = byte_swap_32 (digest
[2]);
10059 digest
[3] = byte_swap_32 (digest
[3]);
10060 digest
[4] = byte_swap_32 (digest
[4]);
10061 digest
[5] = byte_swap_32 (digest
[5]);
10062 digest
[6] = byte_swap_32 (digest
[6]);
10063 digest
[7] = byte_swap_32 (digest
[7]);
10065 digest
[0] -= SHA256M_A
;
10066 digest
[1] -= SHA256M_B
;
10067 digest
[2] -= SHA256M_C
;
10068 digest
[3] -= SHA256M_D
;
10069 digest
[4] -= SHA256M_E
;
10070 digest
[5] -= SHA256M_F
;
10071 digest
[6] -= SHA256M_G
;
10072 digest
[7] -= SHA256M_H
;
10074 return (PARSER_OK
);
10077 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10079 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10081 u32
*digest
= (u32
*) hash_buf
->digest
;
10083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10086 digest
[0] = byte_swap_32 (digest
[0]);
10087 digest
[1] = byte_swap_32 (digest
[1]);
10091 IP (digest
[0], digest
[1], tt
);
10093 digest
[0] = digest
[0];
10094 digest
[1] = digest
[1];
10098 return (PARSER_OK
);
10101 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10103 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10105 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10107 u32
*digest
= (u32
*) hash_buf
->digest
;
10109 salt_t
*salt
= hash_buf
->salt
;
10111 char *hash_pos
= input_buf
+ 10;
10113 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10114 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10115 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10116 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10117 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10119 digest
[0] -= SHA1M_A
;
10120 digest
[1] -= SHA1M_B
;
10121 digest
[2] -= SHA1M_C
;
10122 digest
[3] -= SHA1M_D
;
10123 digest
[4] -= SHA1M_E
;
10125 uint salt_len
= 10;
10127 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10129 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10131 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10133 salt
->salt_len
= salt_len
;
10135 return (PARSER_OK
);
10138 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10140 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10142 u32
*digest
= (u32
*) hash_buf
->digest
;
10144 salt_t
*salt
= hash_buf
->salt
;
10146 char *hash_pos
= input_buf
+ 8;
10148 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10149 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10150 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10151 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10152 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10154 digest
[0] -= SHA1M_A
;
10155 digest
[1] -= SHA1M_B
;
10156 digest
[2] -= SHA1M_C
;
10157 digest
[3] -= SHA1M_D
;
10158 digest
[4] -= SHA1M_E
;
10162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10164 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10166 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10168 salt
->salt_len
= salt_len
;
10170 return (PARSER_OK
);
10173 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10175 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10177 u64
*digest
= (u64
*) hash_buf
->digest
;
10179 salt_t
*salt
= hash_buf
->salt
;
10181 char *hash_pos
= input_buf
+ 8;
10183 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10184 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10185 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10186 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10187 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10188 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10189 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10190 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10192 digest
[0] -= SHA512M_A
;
10193 digest
[1] -= SHA512M_B
;
10194 digest
[2] -= SHA512M_C
;
10195 digest
[3] -= SHA512M_D
;
10196 digest
[4] -= SHA512M_E
;
10197 digest
[5] -= SHA512M_F
;
10198 digest
[6] -= SHA512M_G
;
10199 digest
[7] -= SHA512M_H
;
10203 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10205 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10207 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10209 salt
->salt_len
= salt_len
;
10211 return (PARSER_OK
);
10214 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10216 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10218 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10222 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10225 u32
*digest
= (u32
*) hash_buf
->digest
;
10227 salt_t
*salt
= hash_buf
->salt
;
10229 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10230 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10231 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10232 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10234 digest
[0] = byte_swap_32 (digest
[0]);
10235 digest
[1] = byte_swap_32 (digest
[1]);
10236 digest
[2] = byte_swap_32 (digest
[2]);
10237 digest
[3] = byte_swap_32 (digest
[3]);
10239 digest
[0] -= MD5M_A
;
10240 digest
[1] -= MD5M_B
;
10241 digest
[2] -= MD5M_C
;
10242 digest
[3] -= MD5M_D
;
10244 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10246 uint salt_len
= input_len
- 32 - 1;
10248 char *salt_buf
= input_buf
+ 32 + 1;
10250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_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 netscreen_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_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10269 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10274 char clean_input_buf
[32] = { 0 };
10276 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10277 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10279 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10283 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10289 clean_input_buf
[k
] = input_buf
[i
];
10297 u32
*digest
= (u32
*) hash_buf
->digest
;
10299 salt_t
*salt
= hash_buf
->salt
;
10301 u32 a
, b
, c
, d
, e
, f
;
10303 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10304 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10305 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10306 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10307 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10308 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10310 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10311 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10313 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10314 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10315 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10316 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10317 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10318 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10320 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10321 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10323 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10324 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10325 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10326 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10327 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10328 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10330 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10331 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10333 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10334 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10335 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10336 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10337 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10338 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10340 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10341 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10343 digest
[0] = byte_swap_32 (digest
[0]);
10344 digest
[1] = byte_swap_32 (digest
[1]);
10345 digest
[2] = byte_swap_32 (digest
[2]);
10346 digest
[3] = byte_swap_32 (digest
[3]);
10348 digest
[0] -= MD5M_A
;
10349 digest
[1] -= MD5M_B
;
10350 digest
[2] -= MD5M_C
;
10351 digest
[3] -= MD5M_D
;
10353 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10355 uint salt_len
= input_len
- 30 - 1;
10357 char *salt_buf
= input_buf
+ 30 + 1;
10359 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10361 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10363 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10364 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10366 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10368 salt
->salt_len
= salt_len
;
10370 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10372 salt
->salt_len
+= 22;
10374 return (PARSER_OK
);
10377 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10379 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10381 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10385 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10388 u32
*digest
= (u32
*) hash_buf
->digest
;
10390 salt_t
*salt
= hash_buf
->salt
;
10392 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10393 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10394 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10395 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10396 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10398 digest
[0] -= SHA1M_A
;
10399 digest
[1] -= SHA1M_B
;
10400 digest
[2] -= SHA1M_C
;
10401 digest
[3] -= SHA1M_D
;
10402 digest
[4] -= SHA1M_E
;
10404 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10406 uint salt_len
= input_len
- 40 - 1;
10408 char *salt_buf
= input_buf
+ 40 + 1;
10410 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10412 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10414 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10416 salt
->salt_len
= salt_len
;
10418 return (PARSER_OK
);
10421 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10423 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10425 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10429 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10432 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10434 char *iter_pos
= input_buf
+ 6;
10436 salt_t
*salt
= hash_buf
->salt
;
10438 uint iter
= atoi (iter_pos
);
10442 iter
= ROUNDS_DCC2
;
10445 salt
->salt_iter
= iter
- 1;
10447 char *salt_pos
= strchr (iter_pos
, '#');
10449 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10453 char *digest_pos
= strchr (salt_pos
, '#');
10455 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10459 uint salt_len
= digest_pos
- salt_pos
- 1;
10461 u32
*digest
= (u32
*) hash_buf
->digest
;
10463 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10464 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10465 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10466 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10470 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10474 salt
->salt_len
= salt_len
;
10476 return (PARSER_OK
);
10479 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10481 u32
*digest
= (u32
*) hash_buf
->digest
;
10483 salt_t
*salt
= hash_buf
->salt
;
10485 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10489 memcpy (&in
, input_buf
, input_len
);
10491 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10493 memcpy (digest
, in
.keymic
, 16);
10496 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10497 The phrase "Pairwise key expansion"
10498 Access Point Address (referred to as Authenticator Address AA)
10499 Supplicant Address (referred to as Supplicant Address SA)
10500 Access Point Nonce (referred to as Authenticator Anonce)
10501 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10504 uint salt_len
= strlen (in
.essid
);
10508 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10510 return (PARSER_SALT_LENGTH
);
10513 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10515 salt
->salt_len
= salt_len
;
10517 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10519 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10521 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10523 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10525 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10526 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10530 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10531 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10534 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10536 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10537 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10541 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10542 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10545 for (int i
= 0; i
< 25; i
++)
10547 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10550 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10551 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10552 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10553 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10555 wpa
->keyver
= in
.keyver
;
10557 if (wpa
->keyver
> 255)
10559 log_info ("ATTENTION!");
10560 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10561 log_info (" This could be due to a recent aircrack-ng bug.");
10562 log_info (" The key version was automatically reset to a reasonable value.");
10565 wpa
->keyver
&= 0xff;
10568 wpa
->eapol_size
= in
.eapol_size
;
10570 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10572 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10574 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10576 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10578 if (wpa
->keyver
== 1)
10584 digest
[0] = byte_swap_32 (digest
[0]);
10585 digest
[1] = byte_swap_32 (digest
[1]);
10586 digest
[2] = byte_swap_32 (digest
[2]);
10587 digest
[3] = byte_swap_32 (digest
[3]);
10589 for (int i
= 0; i
< 64; i
++)
10591 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10595 uint32_t *p0
= (uint32_t *) in
.essid
;
10599 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10600 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10602 salt
->salt_buf
[10] = c0
;
10603 salt
->salt_buf
[11] = c1
;
10605 return (PARSER_OK
);
10608 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10610 u32
*digest
= (u32
*) hash_buf
->digest
;
10612 salt_t
*salt
= hash_buf
->salt
;
10614 if (input_len
== 0)
10616 log_error ("Password Safe v2 container not specified");
10621 FILE *fp
= fopen (input_buf
, "rb");
10625 log_error ("%s: %s", input_buf
, strerror (errno
));
10632 memset (&buf
, 0, sizeof (psafe2_hdr
));
10634 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10638 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10640 salt
->salt_buf
[0] = buf
.random
[0];
10641 salt
->salt_buf
[1] = buf
.random
[1];
10643 salt
->salt_len
= 8;
10644 salt
->salt_iter
= 1000;
10646 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10647 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10648 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10649 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10650 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10652 return (PARSER_OK
);
10655 int psafe3_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 (".psafe3 not specified");
10668 FILE *fp
= fopen (input_buf
, "rb");
10672 log_error ("%s: %s", input_buf
, strerror (errno
));
10679 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10683 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10685 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10687 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10689 salt
->salt_iter
= in
.iterations
+ 1;
10691 salt
->salt_buf
[0] = in
.salt_buf
[0];
10692 salt
->salt_buf
[1] = in
.salt_buf
[1];
10693 salt
->salt_buf
[2] = in
.salt_buf
[2];
10694 salt
->salt_buf
[3] = in
.salt_buf
[3];
10695 salt
->salt_buf
[4] = in
.salt_buf
[4];
10696 salt
->salt_buf
[5] = in
.salt_buf
[5];
10697 salt
->salt_buf
[6] = in
.salt_buf
[6];
10698 salt
->salt_buf
[7] = in
.salt_buf
[7];
10700 salt
->salt_len
= 32;
10702 digest
[0] = in
.hash_buf
[0];
10703 digest
[1] = in
.hash_buf
[1];
10704 digest
[2] = in
.hash_buf
[2];
10705 digest
[3] = in
.hash_buf
[3];
10706 digest
[4] = in
.hash_buf
[4];
10707 digest
[5] = in
.hash_buf
[5];
10708 digest
[6] = in
.hash_buf
[6];
10709 digest
[7] = in
.hash_buf
[7];
10711 digest
[0] = byte_swap_32 (digest
[0]);
10712 digest
[1] = byte_swap_32 (digest
[1]);
10713 digest
[2] = byte_swap_32 (digest
[2]);
10714 digest
[3] = byte_swap_32 (digest
[3]);
10715 digest
[4] = byte_swap_32 (digest
[4]);
10716 digest
[5] = byte_swap_32 (digest
[5]);
10717 digest
[6] = byte_swap_32 (digest
[6]);
10718 digest
[7] = byte_swap_32 (digest
[7]);
10720 return (PARSER_OK
);
10723 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10725 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10727 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10729 u32
*digest
= (u32
*) hash_buf
->digest
;
10731 salt_t
*salt
= hash_buf
->salt
;
10733 char *iter_pos
= input_buf
+ 3;
10735 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10737 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10739 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10741 salt
->salt_iter
= salt_iter
;
10743 char *salt_pos
= iter_pos
+ 1;
10747 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10749 salt
->salt_len
= salt_len
;
10751 char *hash_pos
= salt_pos
+ salt_len
;
10753 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10755 return (PARSER_OK
);
10758 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10760 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10762 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10764 u32
*digest
= (u32
*) hash_buf
->digest
;
10766 salt_t
*salt
= hash_buf
->salt
;
10768 char *salt_pos
= input_buf
+ 3;
10770 uint iterations_len
= 0;
10772 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10776 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10778 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10779 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10783 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10787 iterations_len
+= 8;
10791 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10794 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10796 char *hash_pos
= strchr (salt_pos
, '$');
10798 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10800 uint salt_len
= hash_pos
- salt_pos
;
10802 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10804 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10806 salt
->salt_len
= salt_len
;
10810 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10812 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10814 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10816 return (PARSER_OK
);
10819 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10821 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10823 u32
*digest
= (u32
*) hash_buf
->digest
;
10825 salt_t
*salt
= hash_buf
->salt
;
10827 char *salt_pos
= input_buf
+ 6;
10829 uint iterations_len
= 0;
10831 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10835 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10837 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10838 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10842 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10846 iterations_len
+= 8;
10850 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10853 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10855 char *hash_pos
= strchr (salt_pos
, '$');
10857 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10859 uint salt_len
= hash_pos
- salt_pos
;
10861 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10863 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10865 salt
->salt_len
= salt_len
;
10869 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10871 return (PARSER_OK
);
10874 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10876 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10878 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10880 u32
*digest
= (u32
*) hash_buf
->digest
;
10882 salt_t
*salt
= hash_buf
->salt
;
10884 char *salt_pos
= input_buf
+ 14;
10886 char *hash_pos
= strchr (salt_pos
, '*');
10888 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10892 uint salt_len
= hash_pos
- salt_pos
- 1;
10894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10896 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10898 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10900 salt
->salt_len
= salt_len
;
10902 u8 tmp_buf
[100] = { 0 };
10904 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10906 memcpy (digest
, tmp_buf
, 20);
10908 digest
[0] = byte_swap_32 (digest
[0]);
10909 digest
[1] = byte_swap_32 (digest
[1]);
10910 digest
[2] = byte_swap_32 (digest
[2]);
10911 digest
[3] = byte_swap_32 (digest
[3]);
10912 digest
[4] = byte_swap_32 (digest
[4]);
10914 digest
[0] -= SHA1M_A
;
10915 digest
[1] -= SHA1M_B
;
10916 digest
[2] -= SHA1M_C
;
10917 digest
[3] -= SHA1M_D
;
10918 digest
[4] -= SHA1M_E
;
10920 return (PARSER_OK
);
10923 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10925 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10927 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10929 if (c12
& 3) return (PARSER_HASH_VALUE
);
10931 u32
*digest
= (u32
*) hash_buf
->digest
;
10933 salt_t
*salt
= hash_buf
->salt
;
10935 // for ascii_digest
10936 salt
->salt_sign
[0] = input_buf
[0];
10937 salt
->salt_sign
[1] = input_buf
[1];
10939 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10940 | itoa64_to_int (input_buf
[1]) << 6;
10942 salt
->salt_len
= 2;
10944 u8 tmp_buf
[100] = { 0 };
10946 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10948 memcpy (digest
, tmp_buf
, 8);
10952 IP (digest
[0], digest
[1], tt
);
10957 return (PARSER_OK
);
10960 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10962 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10964 u32
*digest
= (u32
*) hash_buf
->digest
;
10966 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10967 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10968 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10969 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10971 digest
[0] = byte_swap_32 (digest
[0]);
10972 digest
[1] = byte_swap_32 (digest
[1]);
10973 digest
[2] = byte_swap_32 (digest
[2]);
10974 digest
[3] = byte_swap_32 (digest
[3]);
10976 digest
[0] -= MD4M_A
;
10977 digest
[1] -= MD4M_B
;
10978 digest
[2] -= MD4M_C
;
10979 digest
[3] -= MD4M_D
;
10981 return (PARSER_OK
);
10984 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10986 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10988 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10992 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10995 u32
*digest
= (u32
*) hash_buf
->digest
;
10997 salt_t
*salt
= hash_buf
->salt
;
10999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11004 digest
[0] = byte_swap_32 (digest
[0]);
11005 digest
[1] = byte_swap_32 (digest
[1]);
11006 digest
[2] = byte_swap_32 (digest
[2]);
11007 digest
[3] = byte_swap_32 (digest
[3]);
11009 digest
[0] -= MD4M_A
;
11010 digest
[1] -= MD4M_B
;
11011 digest
[2] -= MD4M_C
;
11012 digest
[3] -= MD4M_D
;
11014 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11016 uint salt_len
= input_len
- 32 - 1;
11018 char *salt_buf
= input_buf
+ 32 + 1;
11020 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11022 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11024 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11026 salt
->salt_len
= salt_len
;
11028 return (PARSER_OK
);
11031 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11033 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11035 u32
*digest
= (u32
*) hash_buf
->digest
;
11037 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11038 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11039 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11040 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11042 digest
[0] = byte_swap_32 (digest
[0]);
11043 digest
[1] = byte_swap_32 (digest
[1]);
11044 digest
[2] = byte_swap_32 (digest
[2]);
11045 digest
[3] = byte_swap_32 (digest
[3]);
11047 digest
[0] -= MD5M_A
;
11048 digest
[1] -= MD5M_B
;
11049 digest
[2] -= MD5M_C
;
11050 digest
[3] -= MD5M_D
;
11052 return (PARSER_OK
);
11055 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11057 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11059 u32
*digest
= (u32
*) hash_buf
->digest
;
11061 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11062 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11066 digest
[0] = byte_swap_32 (digest
[0]);
11067 digest
[1] = byte_swap_32 (digest
[1]);
11069 return (PARSER_OK
);
11072 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11074 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11076 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11080 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11083 u32
*digest
= (u32
*) hash_buf
->digest
;
11085 salt_t
*salt
= hash_buf
->salt
;
11087 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11088 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11089 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11090 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11092 digest
[0] = byte_swap_32 (digest
[0]);
11093 digest
[1] = byte_swap_32 (digest
[1]);
11094 digest
[2] = byte_swap_32 (digest
[2]);
11095 digest
[3] = byte_swap_32 (digest
[3]);
11097 digest
[0] -= MD5M_A
;
11098 digest
[1] -= MD5M_B
;
11099 digest
[2] -= MD5M_C
;
11100 digest
[3] -= MD5M_D
;
11102 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11104 uint salt_len
= input_len
- 32 - 1;
11106 char *salt_buf
= input_buf
+ 32 + 1;
11108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11114 salt
->salt_len
= salt_len
;
11116 return (PARSER_OK
);
11119 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11121 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11123 u32
*digest
= (u32
*) hash_buf
->digest
;
11125 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11126 | itoa64_to_int (input_buf
[ 1]) << 6
11127 | itoa64_to_int (input_buf
[ 2]) << 12
11128 | itoa64_to_int (input_buf
[ 3]) << 18;
11129 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11130 | itoa64_to_int (input_buf
[ 5]) << 6
11131 | itoa64_to_int (input_buf
[ 6]) << 12
11132 | itoa64_to_int (input_buf
[ 7]) << 18;
11133 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11134 | itoa64_to_int (input_buf
[ 9]) << 6
11135 | itoa64_to_int (input_buf
[10]) << 12
11136 | itoa64_to_int (input_buf
[11]) << 18;
11137 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11138 | itoa64_to_int (input_buf
[13]) << 6
11139 | itoa64_to_int (input_buf
[14]) << 12
11140 | itoa64_to_int (input_buf
[15]) << 18;
11142 digest
[0] -= MD5M_A
;
11143 digest
[1] -= MD5M_B
;
11144 digest
[2] -= MD5M_C
;
11145 digest
[3] -= MD5M_D
;
11147 digest
[0] &= 0x00ffffff;
11148 digest
[1] &= 0x00ffffff;
11149 digest
[2] &= 0x00ffffff;
11150 digest
[3] &= 0x00ffffff;
11152 return (PARSER_OK
);
11155 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11157 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11159 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11163 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11166 u32
*digest
= (u32
*) hash_buf
->digest
;
11168 salt_t
*salt
= hash_buf
->salt
;
11170 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11171 | itoa64_to_int (input_buf
[ 1]) << 6
11172 | itoa64_to_int (input_buf
[ 2]) << 12
11173 | itoa64_to_int (input_buf
[ 3]) << 18;
11174 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11175 | itoa64_to_int (input_buf
[ 5]) << 6
11176 | itoa64_to_int (input_buf
[ 6]) << 12
11177 | itoa64_to_int (input_buf
[ 7]) << 18;
11178 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11179 | itoa64_to_int (input_buf
[ 9]) << 6
11180 | itoa64_to_int (input_buf
[10]) << 12
11181 | itoa64_to_int (input_buf
[11]) << 18;
11182 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11183 | itoa64_to_int (input_buf
[13]) << 6
11184 | itoa64_to_int (input_buf
[14]) << 12
11185 | itoa64_to_int (input_buf
[15]) << 18;
11187 digest
[0] -= MD5M_A
;
11188 digest
[1] -= MD5M_B
;
11189 digest
[2] -= MD5M_C
;
11190 digest
[3] -= MD5M_D
;
11192 digest
[0] &= 0x00ffffff;
11193 digest
[1] &= 0x00ffffff;
11194 digest
[2] &= 0x00ffffff;
11195 digest
[3] &= 0x00ffffff;
11197 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11199 uint salt_len
= input_len
- 16 - 1;
11201 char *salt_buf
= input_buf
+ 16 + 1;
11203 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11205 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11207 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11209 salt
->salt_len
= salt_len
;
11211 return (PARSER_OK
);
11214 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11216 key
[0] = (nthash
[0] >> 0);
11217 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11218 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11219 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11220 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11221 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11222 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11223 key
[7] = (nthash
[6] << 1);
11235 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11237 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11239 u32
*digest
= (u32
*) hash_buf
->digest
;
11241 salt_t
*salt
= hash_buf
->salt
;
11243 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11249 char *user_pos
= input_buf
;
11251 char *unused_pos
= strchr (user_pos
, ':');
11253 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11255 uint user_len
= unused_pos
- user_pos
;
11257 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11261 char *domain_pos
= strchr (unused_pos
, ':');
11263 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11265 uint unused_len
= domain_pos
- unused_pos
;
11267 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11271 char *srvchall_pos
= strchr (domain_pos
, ':');
11273 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11275 uint domain_len
= srvchall_pos
- domain_pos
;
11277 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11281 char *hash_pos
= strchr (srvchall_pos
, ':');
11283 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11285 uint srvchall_len
= hash_pos
- srvchall_pos
;
11287 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11291 char *clichall_pos
= strchr (hash_pos
, ':');
11293 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11295 uint hash_len
= clichall_pos
- hash_pos
;
11297 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11301 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11303 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11306 * store some data for later use
11309 netntlm
->user_len
= user_len
* 2;
11310 netntlm
->domain_len
= domain_len
* 2;
11311 netntlm
->srvchall_len
= srvchall_len
/ 2;
11312 netntlm
->clichall_len
= clichall_len
/ 2;
11314 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11315 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11318 * handle username and domainname
11321 for (uint i
= 0; i
< user_len
; i
++)
11323 *userdomain_ptr
++ = user_pos
[i
];
11324 *userdomain_ptr
++ = 0;
11327 for (uint i
= 0; i
< domain_len
; i
++)
11329 *userdomain_ptr
++ = domain_pos
[i
];
11330 *userdomain_ptr
++ = 0;
11334 * handle server challenge encoding
11337 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11339 const char p0
= srvchall_pos
[i
+ 0];
11340 const char p1
= srvchall_pos
[i
+ 1];
11342 *chall_ptr
++ = hex_convert (p1
) << 0
11343 | hex_convert (p0
) << 4;
11347 * handle client challenge encoding
11350 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11352 const char p0
= clichall_pos
[i
+ 0];
11353 const char p1
= clichall_pos
[i
+ 1];
11355 *chall_ptr
++ = hex_convert (p1
) << 0
11356 | hex_convert (p0
) << 4;
11363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11365 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11369 salt
->salt_len
= salt_len
;
11371 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11372 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11373 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11374 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11376 digest
[0] = byte_swap_32 (digest
[0]);
11377 digest
[1] = byte_swap_32 (digest
[1]);
11378 digest
[2] = byte_swap_32 (digest
[2]);
11379 digest
[3] = byte_swap_32 (digest
[3]);
11381 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11383 uint digest_tmp
[2] = { 0 };
11385 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11386 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11388 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11389 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11391 /* special case 2: ESS */
11393 if (srvchall_len
== 48)
11395 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11397 uint w
[16] = { 0 };
11399 w
[ 0] = netntlm
->chall_buf
[6];
11400 w
[ 1] = netntlm
->chall_buf
[7];
11401 w
[ 2] = netntlm
->chall_buf
[0];
11402 w
[ 3] = netntlm
->chall_buf
[1];
11406 uint dgst
[4] = { 0 };
11415 salt
->salt_buf
[0] = dgst
[0];
11416 salt
->salt_buf
[1] = dgst
[1];
11420 /* precompute netntlmv1 exploit start */
11422 for (uint i
= 0; i
< 0x10000; i
++)
11424 uint key_md4
[2] = { i
, 0 };
11425 uint key_des
[2] = { 0, 0 };
11427 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11429 uint Kc
[16] = { 0 };
11430 uint Kd
[16] = { 0 };
11432 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11434 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11436 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11438 if (data3
[0] != digest_tmp
[0]) continue;
11439 if (data3
[1] != digest_tmp
[1]) continue;
11441 salt
->salt_buf
[2] = i
;
11443 salt
->salt_len
= 24;
11448 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11449 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11451 /* precompute netntlmv1 exploit stop */
11455 IP (digest
[0], digest
[1], tt
);
11456 IP (digest
[2], digest
[3], tt
);
11458 digest
[0] = rotr32 (digest
[0], 29);
11459 digest
[1] = rotr32 (digest
[1], 29);
11460 digest
[2] = rotr32 (digest
[2], 29);
11461 digest
[3] = rotr32 (digest
[3], 29);
11463 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11465 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11466 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11468 return (PARSER_OK
);
11471 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11473 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11475 u32
*digest
= (u32
*) hash_buf
->digest
;
11477 salt_t
*salt
= hash_buf
->salt
;
11479 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11485 char *user_pos
= input_buf
;
11487 char *unused_pos
= strchr (user_pos
, ':');
11489 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11491 uint user_len
= unused_pos
- user_pos
;
11493 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11497 char *domain_pos
= strchr (unused_pos
, ':');
11499 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11501 uint unused_len
= domain_pos
- unused_pos
;
11503 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11507 char *srvchall_pos
= strchr (domain_pos
, ':');
11509 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11511 uint domain_len
= srvchall_pos
- domain_pos
;
11513 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11517 char *hash_pos
= strchr (srvchall_pos
, ':');
11519 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11521 uint srvchall_len
= hash_pos
- srvchall_pos
;
11523 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11527 char *clichall_pos
= strchr (hash_pos
, ':');
11529 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11531 uint hash_len
= clichall_pos
- hash_pos
;
11533 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11537 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11539 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11541 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11544 * store some data for later use
11547 netntlm
->user_len
= user_len
* 2;
11548 netntlm
->domain_len
= domain_len
* 2;
11549 netntlm
->srvchall_len
= srvchall_len
/ 2;
11550 netntlm
->clichall_len
= clichall_len
/ 2;
11552 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11553 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11556 * handle username and domainname
11559 for (uint i
= 0; i
< user_len
; i
++)
11561 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11562 *userdomain_ptr
++ = 0;
11565 for (uint i
= 0; i
< domain_len
; i
++)
11567 *userdomain_ptr
++ = domain_pos
[i
];
11568 *userdomain_ptr
++ = 0;
11571 *userdomain_ptr
++ = 0x80;
11574 * handle server challenge encoding
11577 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11579 const char p0
= srvchall_pos
[i
+ 0];
11580 const char p1
= srvchall_pos
[i
+ 1];
11582 *chall_ptr
++ = hex_convert (p1
) << 0
11583 | hex_convert (p0
) << 4;
11587 * handle client challenge encoding
11590 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11592 const char p0
= clichall_pos
[i
+ 0];
11593 const char p1
= clichall_pos
[i
+ 1];
11595 *chall_ptr
++ = hex_convert (p1
) << 0
11596 | hex_convert (p0
) << 4;
11599 *chall_ptr
++ = 0x80;
11602 * handle hash itself
11605 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11606 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11607 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11608 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11610 digest
[0] = byte_swap_32 (digest
[0]);
11611 digest
[1] = byte_swap_32 (digest
[1]);
11612 digest
[2] = byte_swap_32 (digest
[2]);
11613 digest
[3] = byte_swap_32 (digest
[3]);
11616 * reuse challange data as salt_buf, its the buffer that is most likely unique
11619 salt
->salt_buf
[0] = 0;
11620 salt
->salt_buf
[1] = 0;
11621 salt
->salt_buf
[2] = 0;
11622 salt
->salt_buf
[3] = 0;
11623 salt
->salt_buf
[4] = 0;
11624 salt
->salt_buf
[5] = 0;
11625 salt
->salt_buf
[6] = 0;
11626 salt
->salt_buf
[7] = 0;
11630 uptr
= (uint
*) netntlm
->userdomain_buf
;
11632 for (uint i
= 0; i
< 16; i
+= 16)
11634 md5_64 (uptr
, salt
->salt_buf
);
11637 uptr
= (uint
*) netntlm
->chall_buf
;
11639 for (uint i
= 0; i
< 256; i
+= 16)
11641 md5_64 (uptr
, salt
->salt_buf
);
11644 salt
->salt_len
= 16;
11646 return (PARSER_OK
);
11649 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11651 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11653 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11657 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11660 u32
*digest
= (u32
*) hash_buf
->digest
;
11662 salt_t
*salt
= hash_buf
->salt
;
11664 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11665 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11666 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11667 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11669 digest
[0] = byte_swap_32 (digest
[0]);
11670 digest
[1] = byte_swap_32 (digest
[1]);
11671 digest
[2] = byte_swap_32 (digest
[2]);
11672 digest
[3] = byte_swap_32 (digest
[3]);
11674 digest
[0] -= MD5M_A
;
11675 digest
[1] -= MD5M_B
;
11676 digest
[2] -= MD5M_C
;
11677 digest
[3] -= MD5M_D
;
11679 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11681 uint salt_len
= input_len
- 32 - 1;
11683 char *salt_buf
= input_buf
+ 32 + 1;
11685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11687 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11691 salt
->salt_len
= salt_len
;
11693 return (PARSER_OK
);
11696 int postgresql_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_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11704 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) 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 md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11745 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11747 u32
*digest
= (u32
*) hash_buf
->digest
;
11749 salt_t
*salt
= hash_buf
->salt
;
11751 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11752 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11753 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11754 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11756 digest
[0] = byte_swap_32 (digest
[0]);
11757 digest
[1] = byte_swap_32 (digest
[1]);
11758 digest
[2] = byte_swap_32 (digest
[2]);
11759 digest
[3] = byte_swap_32 (digest
[3]);
11761 digest
[0] -= MD5M_A
;
11762 digest
[1] -= MD5M_B
;
11763 digest
[2] -= MD5M_C
;
11764 digest
[3] -= MD5M_D
;
11767 * This is a virtual salt. While the algorithm is basically not salted
11768 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11769 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11772 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11774 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11776 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11778 salt
->salt_len
= salt_len
;
11780 return (PARSER_OK
);
11783 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11785 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11787 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11791 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) 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
;
11813 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11815 uint salt_len
= input_len
- 32 - 1;
11817 char *salt_buf
= input_buf
+ 32 + 1;
11819 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11821 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11823 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11825 salt
->salt_len
= salt_len
;
11827 return (PARSER_OK
);
11830 int vb30_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_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11838 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) 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 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11857 uint salt_len
= input_len
- 32 - 1;
11859 char *salt_buf
= input_buf
+ 32 + 1;
11861 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11863 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11867 salt
->salt_len
= salt_len
;
11869 return (PARSER_OK
);
11872 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11874 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11876 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11880 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11883 u32
*digest
= (u32
*) hash_buf
->digest
;
11885 salt_t
*salt
= hash_buf
->salt
;
11887 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11888 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11889 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11890 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11892 digest
[0] = byte_swap_32 (digest
[0]);
11893 digest
[1] = byte_swap_32 (digest
[1]);
11894 digest
[2] = byte_swap_32 (digest
[2]);
11895 digest
[3] = byte_swap_32 (digest
[3]);
11897 digest
[0] -= MD4M_A
;
11898 digest
[1] -= MD4M_B
;
11899 digest
[2] -= MD4M_C
;
11900 digest
[3] -= MD4M_D
;
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 ipb2_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_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11927 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) 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 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11946 uint salt_len
= input_len
- 32 - 1;
11948 char *salt_buf
= input_buf
+ 32 + 1;
11950 uint salt_pc_block
[16] = { 0 };
11952 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11954 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11956 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11958 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11960 salt_pc_block
[14] = salt_len
* 8;
11962 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11964 md5_64 (salt_pc_block
, salt_pc_digest
);
11966 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11967 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11968 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11969 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11971 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11973 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11975 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11977 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11978 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11979 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11980 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11982 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11984 return (PARSER_OK
);
11987 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11989 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11991 u32
*digest
= (u32
*) hash_buf
->digest
;
11993 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11994 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11995 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11996 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11997 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11999 digest
[0] -= SHA1M_A
;
12000 digest
[1] -= SHA1M_B
;
12001 digest
[2] -= SHA1M_C
;
12002 digest
[3] -= SHA1M_D
;
12003 digest
[4] -= SHA1M_E
;
12005 return (PARSER_OK
);
12008 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12010 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12012 u32
*digest
= (u32
*) hash_buf
->digest
;
12014 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12015 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12016 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12017 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12018 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12020 return (PARSER_OK
);
12023 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12025 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12027 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12029 u32
*digest
= (u32
*) hash_buf
->digest
;
12033 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12034 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12035 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12036 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12039 return (PARSER_OK
);
12042 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12044 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12046 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12050 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12053 u32
*digest
= (u32
*) hash_buf
->digest
;
12055 salt_t
*salt
= hash_buf
->salt
;
12057 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12058 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12059 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12060 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12061 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12063 digest
[0] -= SHA1M_A
;
12064 digest
[1] -= SHA1M_B
;
12065 digest
[2] -= SHA1M_C
;
12066 digest
[3] -= SHA1M_D
;
12067 digest
[4] -= SHA1M_E
;
12069 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12071 uint salt_len
= input_len
- 40 - 1;
12073 char *salt_buf
= input_buf
+ 40 + 1;
12075 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12077 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12079 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12081 salt
->salt_len
= salt_len
;
12083 return (PARSER_OK
);
12086 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12088 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12090 u32
*digest
= (u32
*) hash_buf
->digest
;
12092 salt_t
*salt
= hash_buf
->salt
;
12094 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12096 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12097 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12098 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12099 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12100 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12102 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12104 uint salt_len
= input_len
- 40 - 1;
12106 char *salt_buf
= input_buf
+ 40 + 1;
12108 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12110 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12112 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12114 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12117 pstoken
->salt_len
= salt_len
/ 2;
12119 /* some fake salt for the sorting mechanisms */
12121 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12122 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12123 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12124 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12125 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12126 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12127 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12128 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12130 salt
->salt_len
= 32;
12132 /* we need to check if we can precompute some of the data --
12133 this is possible since the scheme is badly designed */
12135 pstoken
->pc_digest
[0] = SHA1M_A
;
12136 pstoken
->pc_digest
[1] = SHA1M_B
;
12137 pstoken
->pc_digest
[2] = SHA1M_C
;
12138 pstoken
->pc_digest
[3] = SHA1M_D
;
12139 pstoken
->pc_digest
[4] = SHA1M_E
;
12141 pstoken
->pc_offset
= 0;
12143 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12147 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12148 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12149 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12150 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12151 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12152 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12153 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12154 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12155 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12156 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12157 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12158 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12159 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12160 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12161 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12162 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12164 sha1_64 (w
, pstoken
->pc_digest
);
12166 pstoken
->pc_offset
+= 16;
12169 return (PARSER_OK
);
12172 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12174 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12176 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12178 u32
*digest
= (u32
*) hash_buf
->digest
;
12180 u8 tmp_buf
[100] = { 0 };
12182 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12184 memcpy (digest
, tmp_buf
, 20);
12186 digest
[0] = byte_swap_32 (digest
[0]);
12187 digest
[1] = byte_swap_32 (digest
[1]);
12188 digest
[2] = byte_swap_32 (digest
[2]);
12189 digest
[3] = byte_swap_32 (digest
[3]);
12190 digest
[4] = byte_swap_32 (digest
[4]);
12192 digest
[0] -= SHA1M_A
;
12193 digest
[1] -= SHA1M_B
;
12194 digest
[2] -= SHA1M_C
;
12195 digest
[3] -= SHA1M_D
;
12196 digest
[4] -= SHA1M_E
;
12198 return (PARSER_OK
);
12201 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12203 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12205 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12207 u32
*digest
= (u32
*) hash_buf
->digest
;
12209 salt_t
*salt
= hash_buf
->salt
;
12211 u8 tmp_buf
[100] = { 0 };
12213 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12215 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12217 memcpy (digest
, tmp_buf
, 20);
12219 int salt_len
= tmp_len
- 20;
12221 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12223 salt
->salt_len
= salt_len
;
12225 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12227 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12229 char *ptr
= (char *) salt
->salt_buf
;
12231 ptr
[salt
->salt_len
] = 0x80;
12234 digest
[0] = byte_swap_32 (digest
[0]);
12235 digest
[1] = byte_swap_32 (digest
[1]);
12236 digest
[2] = byte_swap_32 (digest
[2]);
12237 digest
[3] = byte_swap_32 (digest
[3]);
12238 digest
[4] = byte_swap_32 (digest
[4]);
12240 digest
[0] -= SHA1M_A
;
12241 digest
[1] -= SHA1M_B
;
12242 digest
[2] -= SHA1M_C
;
12243 digest
[3] -= SHA1M_D
;
12244 digest
[4] -= SHA1M_E
;
12246 return (PARSER_OK
);
12249 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12251 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12253 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12255 u32
*digest
= (u32
*) hash_buf
->digest
;
12257 salt_t
*salt
= hash_buf
->salt
;
12259 char *salt_buf
= input_buf
+ 6;
12263 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12265 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12267 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12269 salt
->salt_len
= salt_len
;
12271 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12273 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12274 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12275 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12276 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12277 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12279 digest
[0] -= SHA1M_A
;
12280 digest
[1] -= SHA1M_B
;
12281 digest
[2] -= SHA1M_C
;
12282 digest
[3] -= SHA1M_D
;
12283 digest
[4] -= SHA1M_E
;
12285 return (PARSER_OK
);
12288 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12290 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12292 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12294 u32
*digest
= (u32
*) hash_buf
->digest
;
12296 salt_t
*salt
= hash_buf
->salt
;
12298 char *salt_buf
= input_buf
+ 6;
12302 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12304 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12306 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12308 salt
->salt_len
= salt_len
;
12310 char *hash_pos
= input_buf
+ 6 + 8;
12312 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12313 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12314 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12315 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12316 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12318 digest
[0] -= SHA1M_A
;
12319 digest
[1] -= SHA1M_B
;
12320 digest
[2] -= SHA1M_C
;
12321 digest
[3] -= SHA1M_D
;
12322 digest
[4] -= SHA1M_E
;
12324 return (PARSER_OK
);
12327 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12329 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12331 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12333 u64
*digest
= (u64
*) hash_buf
->digest
;
12335 salt_t
*salt
= hash_buf
->salt
;
12337 char *salt_buf
= input_buf
+ 6;
12341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12347 salt
->salt_len
= salt_len
;
12349 char *hash_pos
= input_buf
+ 6 + 8;
12351 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12352 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12353 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12354 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12355 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12356 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12357 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12358 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12360 digest
[0] -= SHA512M_A
;
12361 digest
[1] -= SHA512M_B
;
12362 digest
[2] -= SHA512M_C
;
12363 digest
[3] -= SHA512M_D
;
12364 digest
[4] -= SHA512M_E
;
12365 digest
[5] -= SHA512M_F
;
12366 digest
[6] -= SHA512M_G
;
12367 digest
[7] -= SHA512M_H
;
12369 return (PARSER_OK
);
12372 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12374 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12376 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12380 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12383 u32
*digest
= (u32
*) hash_buf
->digest
;
12385 salt_t
*salt
= hash_buf
->salt
;
12387 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12388 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12392 digest
[0] = byte_swap_32 (digest
[0]);
12393 digest
[1] = byte_swap_32 (digest
[1]);
12395 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12397 uint salt_len
= input_len
- 16 - 1;
12399 char *salt_buf
= input_buf
+ 16 + 1;
12401 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12403 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12405 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12407 salt
->salt_len
= salt_len
;
12409 return (PARSER_OK
);
12412 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12414 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12416 u32
*digest
= (u32
*) hash_buf
->digest
;
12418 salt_t
*salt
= hash_buf
->salt
;
12420 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12421 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12422 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12423 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12424 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12426 digest
[0] -= SHA1M_A
;
12427 digest
[1] -= SHA1M_B
;
12428 digest
[2] -= SHA1M_C
;
12429 digest
[3] -= SHA1M_D
;
12430 digest
[4] -= SHA1M_E
;
12432 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12434 uint salt_len
= input_len
- 40 - 1;
12436 char *salt_buf
= input_buf
+ 40 + 1;
12438 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12440 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12442 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12444 salt
->salt_len
= salt_len
;
12446 return (PARSER_OK
);
12449 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12451 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12453 u32
*digest
= (u32
*) hash_buf
->digest
;
12455 salt_t
*salt
= hash_buf
->salt
;
12457 char *hash_pos
= input_buf
;
12459 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12460 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12461 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12462 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12463 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12464 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12465 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12466 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12467 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12468 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12469 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12470 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12471 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12472 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12473 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12474 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12476 char *salt_pos
= input_buf
+ 128;
12478 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12479 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12480 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12481 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12483 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12484 salt
->salt_len
= 16;
12486 return (PARSER_OK
);
12489 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12491 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12493 u32
*digest
= (u32
*) hash_buf
->digest
;
12495 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12496 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12497 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12498 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12499 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12500 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12501 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12502 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12504 digest
[0] -= SHA256M_A
;
12505 digest
[1] -= SHA256M_B
;
12506 digest
[2] -= SHA256M_C
;
12507 digest
[3] -= SHA256M_D
;
12508 digest
[4] -= SHA256M_E
;
12509 digest
[5] -= SHA256M_F
;
12510 digest
[6] -= SHA256M_G
;
12511 digest
[7] -= SHA256M_H
;
12513 return (PARSER_OK
);
12516 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12518 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12520 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12524 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12527 u32
*digest
= (u32
*) hash_buf
->digest
;
12529 salt_t
*salt
= hash_buf
->salt
;
12531 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12532 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12533 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12534 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12535 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12536 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12537 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12538 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12540 digest
[0] -= SHA256M_A
;
12541 digest
[1] -= SHA256M_B
;
12542 digest
[2] -= SHA256M_C
;
12543 digest
[3] -= SHA256M_D
;
12544 digest
[4] -= SHA256M_E
;
12545 digest
[5] -= SHA256M_F
;
12546 digest
[6] -= SHA256M_G
;
12547 digest
[7] -= SHA256M_H
;
12549 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12551 uint salt_len
= input_len
- 64 - 1;
12553 char *salt_buf
= input_buf
+ 64 + 1;
12555 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12557 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12559 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12561 salt
->salt_len
= salt_len
;
12563 return (PARSER_OK
);
12566 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12568 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12570 u64
*digest
= (u64
*) hash_buf
->digest
;
12572 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12573 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12574 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12575 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12576 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12577 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12581 digest
[0] -= SHA384M_A
;
12582 digest
[1] -= SHA384M_B
;
12583 digest
[2] -= SHA384M_C
;
12584 digest
[3] -= SHA384M_D
;
12585 digest
[4] -= SHA384M_E
;
12586 digest
[5] -= SHA384M_F
;
12590 return (PARSER_OK
);
12593 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12595 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12597 u64
*digest
= (u64
*) hash_buf
->digest
;
12599 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12600 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12601 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12602 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12603 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12604 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12605 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12606 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12608 digest
[0] -= SHA512M_A
;
12609 digest
[1] -= SHA512M_B
;
12610 digest
[2] -= SHA512M_C
;
12611 digest
[3] -= SHA512M_D
;
12612 digest
[4] -= SHA512M_E
;
12613 digest
[5] -= SHA512M_F
;
12614 digest
[6] -= SHA512M_G
;
12615 digest
[7] -= SHA512M_H
;
12617 return (PARSER_OK
);
12620 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12622 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12624 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12628 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12631 u64
*digest
= (u64
*) hash_buf
->digest
;
12633 salt_t
*salt
= hash_buf
->salt
;
12635 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12636 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12637 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12638 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12639 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12640 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12641 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12642 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12644 digest
[0] -= SHA512M_A
;
12645 digest
[1] -= SHA512M_B
;
12646 digest
[2] -= SHA512M_C
;
12647 digest
[3] -= SHA512M_D
;
12648 digest
[4] -= SHA512M_E
;
12649 digest
[5] -= SHA512M_F
;
12650 digest
[6] -= SHA512M_G
;
12651 digest
[7] -= SHA512M_H
;
12653 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12655 uint salt_len
= input_len
- 128 - 1;
12657 char *salt_buf
= input_buf
+ 128 + 1;
12659 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12661 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12663 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12665 salt
->salt_len
= salt_len
;
12667 return (PARSER_OK
);
12670 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12672 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12674 u64
*digest
= (u64
*) hash_buf
->digest
;
12676 salt_t
*salt
= hash_buf
->salt
;
12678 char *salt_pos
= input_buf
+ 3;
12680 uint iterations_len
= 0;
12682 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12686 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12688 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12689 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12693 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12697 iterations_len
+= 8;
12701 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12704 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12706 char *hash_pos
= strchr (salt_pos
, '$');
12708 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12710 uint salt_len
= hash_pos
- salt_pos
;
12712 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12714 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12716 salt
->salt_len
= salt_len
;
12720 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12722 return (PARSER_OK
);
12725 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12727 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12729 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12731 u64
*digest
= (u64
*) hash_buf
->digest
;
12733 salt_t
*salt
= hash_buf
->salt
;
12735 uint keccak_mdlen
= input_len
/ 2;
12737 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12739 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12741 digest
[i
] = byte_swap_64 (digest
[i
]);
12744 salt
->keccak_mdlen
= keccak_mdlen
;
12746 return (PARSER_OK
);
12749 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12751 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12753 u32
*digest
= (u32
*) hash_buf
->digest
;
12755 salt_t
*salt
= hash_buf
->salt
;
12757 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12760 * Parse that strange long line
12765 size_t in_len
[9] = { 0 };
12767 in_off
[0] = strtok (input_buf
, ":");
12769 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12771 in_len
[0] = strlen (in_off
[0]);
12775 for (i
= 1; i
< 9; i
++)
12777 in_off
[i
] = strtok (NULL
, ":");
12779 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12781 in_len
[i
] = strlen (in_off
[i
]);
12784 char *ptr
= (char *) ikepsk
->msg_buf
;
12786 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12787 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12788 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12789 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12790 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12791 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12795 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12797 ptr
= (char *) ikepsk
->nr_buf
;
12799 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12800 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12804 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12807 * Store to database
12812 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12813 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12814 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12815 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12817 digest
[0] = byte_swap_32 (digest
[0]);
12818 digest
[1] = byte_swap_32 (digest
[1]);
12819 digest
[2] = byte_swap_32 (digest
[2]);
12820 digest
[3] = byte_swap_32 (digest
[3]);
12822 salt
->salt_len
= 32;
12824 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12825 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12826 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12827 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12828 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12829 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12830 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12831 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12833 return (PARSER_OK
);
12836 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12838 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12840 u32
*digest
= (u32
*) hash_buf
->digest
;
12842 salt_t
*salt
= hash_buf
->salt
;
12844 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12847 * Parse that strange long line
12852 size_t in_len
[9] = { 0 };
12854 in_off
[0] = strtok (input_buf
, ":");
12856 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12858 in_len
[0] = strlen (in_off
[0]);
12862 for (i
= 1; i
< 9; i
++)
12864 in_off
[i
] = strtok (NULL
, ":");
12866 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12868 in_len
[i
] = strlen (in_off
[i
]);
12871 char *ptr
= (char *) ikepsk
->msg_buf
;
12873 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12874 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12875 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12876 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12877 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12878 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12882 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12884 ptr
= (char *) ikepsk
->nr_buf
;
12886 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12887 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12891 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12894 * Store to database
12899 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12900 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12901 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12902 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12903 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12905 salt
->salt_len
= 32;
12907 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12908 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12909 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12910 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12911 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12912 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12913 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12914 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12916 return (PARSER_OK
);
12919 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12921 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12923 u32
*digest
= (u32
*) hash_buf
->digest
;
12925 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12926 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12927 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12928 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12929 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12931 digest
[0] = byte_swap_32 (digest
[0]);
12932 digest
[1] = byte_swap_32 (digest
[1]);
12933 digest
[2] = byte_swap_32 (digest
[2]);
12934 digest
[3] = byte_swap_32 (digest
[3]);
12935 digest
[4] = byte_swap_32 (digest
[4]);
12937 return (PARSER_OK
);
12940 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12942 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12944 u32
*digest
= (u32
*) hash_buf
->digest
;
12946 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12947 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12948 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12949 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12950 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12951 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12952 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12953 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12954 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12955 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12956 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12957 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12958 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12959 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12960 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12961 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12963 return (PARSER_OK
);
12966 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12968 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12970 u32
*digest
= (u32
*) hash_buf
->digest
;
12972 salt_t
*salt
= hash_buf
->salt
;
12974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12976 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12977 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12978 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12980 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12982 uint salt_len
= input_len
- 40 - 1;
12984 char *salt_buf
= input_buf
+ 40 + 1;
12986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12988 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12992 salt
->salt_len
= salt_len
;
12994 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12996 return (PARSER_OK
);
12999 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13001 u32
*digest
= (u32
*) hash_buf
->digest
;
13003 salt_t
*salt
= hash_buf
->salt
;
13005 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13007 if (input_len
== 0)
13009 log_error ("TrueCrypt container not specified");
13014 FILE *fp
= fopen (input_buf
, "rb");
13018 log_error ("%s: %s", input_buf
, strerror (errno
));
13023 char buf
[512] = { 0 };
13025 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13029 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13031 memcpy (tc
->salt_buf
, buf
, 64);
13033 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13035 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13037 salt
->salt_len
= 4;
13039 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13041 tc
->signature
= 0x45555254; // "TRUE"
13043 digest
[0] = tc
->data_buf
[0];
13045 return (PARSER_OK
);
13048 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13050 u32
*digest
= (u32
*) hash_buf
->digest
;
13052 salt_t
*salt
= hash_buf
->salt
;
13054 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13056 if (input_len
== 0)
13058 log_error ("TrueCrypt container not specified");
13063 FILE *fp
= fopen (input_buf
, "rb");
13067 log_error ("%s: %s", input_buf
, strerror (errno
));
13072 char buf
[512] = { 0 };
13074 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13078 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13080 memcpy (tc
->salt_buf
, buf
, 64);
13082 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13084 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13086 salt
->salt_len
= 4;
13088 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13090 tc
->signature
= 0x45555254; // "TRUE"
13092 digest
[0] = tc
->data_buf
[0];
13094 return (PARSER_OK
);
13097 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13099 u32
*digest
= (u32
*) hash_buf
->digest
;
13101 salt_t
*salt
= hash_buf
->salt
;
13103 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13105 if (input_len
== 0)
13107 log_error ("VeraCrypt container not specified");
13112 FILE *fp
= fopen (input_buf
, "rb");
13116 log_error ("%s: %s", input_buf
, strerror (errno
));
13121 char buf
[512] = { 0 };
13123 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13127 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13129 memcpy (tc
->salt_buf
, buf
, 64);
13131 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13133 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13135 salt
->salt_len
= 4;
13137 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13139 tc
->signature
= 0x41524556; // "VERA"
13141 digest
[0] = tc
->data_buf
[0];
13143 return (PARSER_OK
);
13146 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13148 u32
*digest
= (u32
*) hash_buf
->digest
;
13150 salt_t
*salt
= hash_buf
->salt
;
13152 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13154 if (input_len
== 0)
13156 log_error ("VeraCrypt container not specified");
13161 FILE *fp
= fopen (input_buf
, "rb");
13165 log_error ("%s: %s", input_buf
, strerror (errno
));
13170 char buf
[512] = { 0 };
13172 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13176 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13178 memcpy (tc
->salt_buf
, buf
, 64);
13180 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13182 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13184 salt
->salt_len
= 4;
13186 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13188 tc
->signature
= 0x41524556; // "VERA"
13190 digest
[0] = tc
->data_buf
[0];
13192 return (PARSER_OK
);
13195 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13197 u32
*digest
= (u32
*) hash_buf
->digest
;
13199 salt_t
*salt
= hash_buf
->salt
;
13201 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13203 if (input_len
== 0)
13205 log_error ("VeraCrypt container not specified");
13210 FILE *fp
= fopen (input_buf
, "rb");
13214 log_error ("%s: %s", input_buf
, strerror (errno
));
13219 char buf
[512] = { 0 };
13221 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13225 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13227 memcpy (tc
->salt_buf
, buf
, 64);
13229 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13231 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13233 salt
->salt_len
= 4;
13235 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13237 tc
->signature
= 0x41524556; // "VERA"
13239 digest
[0] = tc
->data_buf
[0];
13241 return (PARSER_OK
);
13244 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13246 u32
*digest
= (u32
*) hash_buf
->digest
;
13248 salt_t
*salt
= hash_buf
->salt
;
13250 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13252 if (input_len
== 0)
13254 log_error ("VeraCrypt container not specified");
13259 FILE *fp
= fopen (input_buf
, "rb");
13263 log_error ("%s: %s", input_buf
, strerror (errno
));
13268 char buf
[512] = { 0 };
13270 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13274 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13276 memcpy (tc
->salt_buf
, buf
, 64);
13278 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13280 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13282 salt
->salt_len
= 4;
13284 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13286 tc
->signature
= 0x41524556; // "VERA"
13288 digest
[0] = tc
->data_buf
[0];
13290 return (PARSER_OK
);
13293 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13295 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13297 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13299 u32
*digest
= (u32
*) hash_buf
->digest
;
13301 salt_t
*salt
= hash_buf
->salt
;
13303 char *salt_pos
= input_buf
+ 6;
13305 char *hash_pos
= strchr (salt_pos
, '$');
13307 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13309 uint salt_len
= hash_pos
- salt_pos
;
13311 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13313 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13315 salt
->salt_len
= salt_len
;
13317 salt
->salt_iter
= 1000;
13321 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13323 return (PARSER_OK
);
13326 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13328 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13330 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13332 u32
*digest
= (u32
*) hash_buf
->digest
;
13334 salt_t
*salt
= hash_buf
->salt
;
13336 char *iter_pos
= input_buf
+ 7;
13338 char *salt_pos
= strchr (iter_pos
, '$');
13340 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13344 char *hash_pos
= strchr (salt_pos
, '$');
13346 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13348 uint salt_len
= hash_pos
- salt_pos
;
13350 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13352 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13354 salt
->salt_len
= salt_len
;
13356 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13358 salt
->salt_sign
[0] = atoi (salt_iter
);
13360 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13364 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13366 digest
[0] = byte_swap_32 (digest
[0]);
13367 digest
[1] = byte_swap_32 (digest
[1]);
13368 digest
[2] = byte_swap_32 (digest
[2]);
13369 digest
[3] = byte_swap_32 (digest
[3]);
13370 digest
[4] = byte_swap_32 (digest
[4]);
13372 return (PARSER_OK
);
13375 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13377 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13379 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13381 u32
*digest
= (u32
*) hash_buf
->digest
;
13383 salt_t
*salt
= hash_buf
->salt
;
13385 char *iter_pos
= input_buf
+ 9;
13387 char *salt_pos
= strchr (iter_pos
, '$');
13389 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13393 char *hash_pos
= strchr (salt_pos
, '$');
13395 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13397 uint salt_len
= hash_pos
- salt_pos
;
13399 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13401 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13403 salt
->salt_len
= salt_len
;
13405 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13407 salt
->salt_sign
[0] = atoi (salt_iter
);
13409 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13413 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13415 digest
[0] = byte_swap_32 (digest
[0]);
13416 digest
[1] = byte_swap_32 (digest
[1]);
13417 digest
[2] = byte_swap_32 (digest
[2]);
13418 digest
[3] = byte_swap_32 (digest
[3]);
13419 digest
[4] = byte_swap_32 (digest
[4]);
13420 digest
[5] = byte_swap_32 (digest
[5]);
13421 digest
[6] = byte_swap_32 (digest
[6]);
13422 digest
[7] = byte_swap_32 (digest
[7]);
13424 return (PARSER_OK
);
13427 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13429 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13431 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13433 u64
*digest
= (u64
*) hash_buf
->digest
;
13435 salt_t
*salt
= hash_buf
->salt
;
13437 char *iter_pos
= input_buf
+ 9;
13439 char *salt_pos
= strchr (iter_pos
, '$');
13441 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13445 char *hash_pos
= strchr (salt_pos
, '$');
13447 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13449 uint salt_len
= hash_pos
- salt_pos
;
13451 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13453 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13455 salt
->salt_len
= salt_len
;
13457 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13459 salt
->salt_sign
[0] = atoi (salt_iter
);
13461 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13465 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13467 digest
[0] = byte_swap_64 (digest
[0]);
13468 digest
[1] = byte_swap_64 (digest
[1]);
13469 digest
[2] = byte_swap_64 (digest
[2]);
13470 digest
[3] = byte_swap_64 (digest
[3]);
13471 digest
[4] = byte_swap_64 (digest
[4]);
13472 digest
[5] = byte_swap_64 (digest
[5]);
13473 digest
[6] = byte_swap_64 (digest
[6]);
13474 digest
[7] = byte_swap_64 (digest
[7]);
13476 return (PARSER_OK
);
13479 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13481 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13483 u32
*digest
= (u32
*) hash_buf
->digest
;
13485 salt_t
*salt
= hash_buf
->salt
;
13487 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13493 char *iterations_pos
= input_buf
;
13495 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13497 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13499 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13501 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13505 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13507 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13509 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13511 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13513 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13515 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13520 * pbkdf2 iterations
13523 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13526 * handle salt encoding
13529 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13531 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13533 const char p0
= saltbuf_pos
[i
+ 0];
13534 const char p1
= saltbuf_pos
[i
+ 1];
13536 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13537 | hex_convert (p0
) << 4;
13540 salt
->salt_len
= saltbuf_len
/ 2;
13543 * handle cipher encoding
13546 uint
*tmp
= (uint
*) mymalloc (32);
13548 char *cipherbuf_ptr
= (char *) tmp
;
13550 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13552 const char p0
= cipherbuf_pos
[i
+ 0];
13553 const char p1
= cipherbuf_pos
[i
+ 1];
13555 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13556 | hex_convert (p0
) << 4;
13559 // iv is stored at salt_buf 4 (length 16)
13560 // data is stored at salt_buf 8 (length 16)
13562 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13563 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13564 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13565 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13567 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13568 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13569 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13570 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13574 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13576 const char p0
= cipherbuf_pos
[j
+ 0];
13577 const char p1
= cipherbuf_pos
[j
+ 1];
13579 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13580 | hex_convert (p0
) << 4;
13587 digest
[0] = 0x10101010;
13588 digest
[1] = 0x10101010;
13589 digest
[2] = 0x10101010;
13590 digest
[3] = 0x10101010;
13592 return (PARSER_OK
);
13595 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13597 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13599 u32
*digest
= (u32
*) hash_buf
->digest
;
13601 salt_t
*salt
= hash_buf
->salt
;
13603 char *hashbuf_pos
= input_buf
;
13605 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13607 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13609 uint hash_len
= iterations_pos
- hashbuf_pos
;
13611 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13615 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13617 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13619 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13623 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13625 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13627 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13629 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13631 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13633 salt
->salt_len
= salt_len
;
13635 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13637 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13638 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13639 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13640 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13642 return (PARSER_OK
);
13645 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13647 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13649 u32
*digest
= (u32
*) hash_buf
->digest
;
13651 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13652 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13653 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13654 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13655 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13656 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13657 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13658 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13660 digest
[0] = byte_swap_32 (digest
[0]);
13661 digest
[1] = byte_swap_32 (digest
[1]);
13662 digest
[2] = byte_swap_32 (digest
[2]);
13663 digest
[3] = byte_swap_32 (digest
[3]);
13664 digest
[4] = byte_swap_32 (digest
[4]);
13665 digest
[5] = byte_swap_32 (digest
[5]);
13666 digest
[6] = byte_swap_32 (digest
[6]);
13667 digest
[7] = byte_swap_32 (digest
[7]);
13669 return (PARSER_OK
);
13672 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13674 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13676 u32
*digest
= (u32
*) hash_buf
->digest
;
13678 salt_t
*salt
= hash_buf
->salt
;
13680 char *salt_pos
= input_buf
+ 3;
13682 uint iterations_len
= 0;
13684 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13688 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13690 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13691 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13695 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13699 iterations_len
+= 8;
13703 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13706 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13708 char *hash_pos
= strchr (salt_pos
, '$');
13710 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13712 uint salt_len
= hash_pos
- salt_pos
;
13714 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13716 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13718 salt
->salt_len
= salt_len
;
13722 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13724 return (PARSER_OK
);
13727 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13729 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13731 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13733 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13735 u64
*digest
= (u64
*) hash_buf
->digest
;
13737 salt_t
*salt
= hash_buf
->salt
;
13739 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13741 char *iter_pos
= input_buf
+ 4;
13743 char *salt_pos
= strchr (iter_pos
, '$');
13745 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13749 char *hash_pos
= strchr (salt_pos
, '$');
13751 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13753 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13757 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13758 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13759 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13760 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13761 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13762 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13763 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13764 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13766 uint salt_len
= hash_pos
- salt_pos
- 1;
13768 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13770 salt
->salt_len
= salt_len
/ 2;
13772 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13773 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13774 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13775 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13776 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13777 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13778 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13779 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13781 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13782 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13783 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13784 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13785 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13786 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13787 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13788 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13789 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13790 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13792 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13794 salt
->salt_iter
= atoi (iter_pos
) - 1;
13796 return (PARSER_OK
);
13799 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13801 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13803 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13805 u32
*digest
= (u32
*) hash_buf
->digest
;
13807 salt_t
*salt
= hash_buf
->salt
;
13809 char *salt_pos
= input_buf
+ 14;
13811 char *hash_pos
= strchr (salt_pos
, '*');
13813 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13817 uint salt_len
= hash_pos
- salt_pos
- 1;
13819 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13821 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13823 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13825 salt
->salt_len
= salt_len
;
13827 u8 tmp_buf
[100] = { 0 };
13829 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13831 memcpy (digest
, tmp_buf
, 32);
13833 digest
[0] = byte_swap_32 (digest
[0]);
13834 digest
[1] = byte_swap_32 (digest
[1]);
13835 digest
[2] = byte_swap_32 (digest
[2]);
13836 digest
[3] = byte_swap_32 (digest
[3]);
13837 digest
[4] = byte_swap_32 (digest
[4]);
13838 digest
[5] = byte_swap_32 (digest
[5]);
13839 digest
[6] = byte_swap_32 (digest
[6]);
13840 digest
[7] = byte_swap_32 (digest
[7]);
13842 digest
[0] -= SHA256M_A
;
13843 digest
[1] -= SHA256M_B
;
13844 digest
[2] -= SHA256M_C
;
13845 digest
[3] -= SHA256M_D
;
13846 digest
[4] -= SHA256M_E
;
13847 digest
[5] -= SHA256M_F
;
13848 digest
[6] -= SHA256M_G
;
13849 digest
[7] -= SHA256M_H
;
13851 return (PARSER_OK
);
13854 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13856 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13858 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13860 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13862 u64
*digest
= (u64
*) hash_buf
->digest
;
13864 salt_t
*salt
= hash_buf
->salt
;
13866 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13868 char *iter_pos
= input_buf
+ 19;
13870 char *salt_pos
= strchr (iter_pos
, '.');
13872 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13876 char *hash_pos
= strchr (salt_pos
, '.');
13878 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13880 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13884 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13885 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13886 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13887 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13888 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13889 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13890 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13891 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13893 uint salt_len
= hash_pos
- salt_pos
- 1;
13897 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13901 for (i
= 0; i
< salt_len
; i
++)
13903 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13906 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13907 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13909 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13911 salt
->salt_len
= salt_len
;
13913 salt
->salt_iter
= atoi (iter_pos
) - 1;
13915 return (PARSER_OK
);
13918 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13920 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13922 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13924 u64
*digest
= (u64
*) hash_buf
->digest
;
13926 salt_t
*salt
= hash_buf
->salt
;
13928 u8 tmp_buf
[120] = { 0 };
13930 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13932 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13934 memcpy (digest
, tmp_buf
, 64);
13936 digest
[0] = byte_swap_64 (digest
[0]);
13937 digest
[1] = byte_swap_64 (digest
[1]);
13938 digest
[2] = byte_swap_64 (digest
[2]);
13939 digest
[3] = byte_swap_64 (digest
[3]);
13940 digest
[4] = byte_swap_64 (digest
[4]);
13941 digest
[5] = byte_swap_64 (digest
[5]);
13942 digest
[6] = byte_swap_64 (digest
[6]);
13943 digest
[7] = byte_swap_64 (digest
[7]);
13945 digest
[0] -= SHA512M_A
;
13946 digest
[1] -= SHA512M_B
;
13947 digest
[2] -= SHA512M_C
;
13948 digest
[3] -= SHA512M_D
;
13949 digest
[4] -= SHA512M_E
;
13950 digest
[5] -= SHA512M_F
;
13951 digest
[6] -= SHA512M_G
;
13952 digest
[7] -= SHA512M_H
;
13954 int salt_len
= tmp_len
- 64;
13956 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13958 salt
->salt_len
= salt_len
;
13960 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13962 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13964 char *ptr
= (char *) salt
->salt_buf
;
13966 ptr
[salt
->salt_len
] = 0x80;
13969 return (PARSER_OK
);
13972 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13974 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13976 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13980 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13983 u32
*digest
= (u32
*) hash_buf
->digest
;
13985 salt_t
*salt
= hash_buf
->salt
;
13987 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13988 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13989 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13990 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13992 digest
[0] = byte_swap_32 (digest
[0]);
13993 digest
[1] = byte_swap_32 (digest
[1]);
13994 digest
[2] = byte_swap_32 (digest
[2]);
13995 digest
[3] = byte_swap_32 (digest
[3]);
13997 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13999 uint salt_len
= input_len
- 32 - 1;
14001 char *salt_buf
= input_buf
+ 32 + 1;
14003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14009 salt
->salt_len
= salt_len
;
14011 return (PARSER_OK
);
14014 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14016 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14018 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14022 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14025 u32
*digest
= (u32
*) hash_buf
->digest
;
14027 salt_t
*salt
= hash_buf
->salt
;
14029 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14030 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14031 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14032 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14033 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14035 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14037 uint salt_len
= input_len
- 40 - 1;
14039 char *salt_buf
= input_buf
+ 40 + 1;
14041 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14043 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14045 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14047 salt
->salt_len
= salt_len
;
14049 return (PARSER_OK
);
14052 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14054 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14056 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14060 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14063 u32
*digest
= (u32
*) hash_buf
->digest
;
14065 salt_t
*salt
= hash_buf
->salt
;
14067 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14068 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14069 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14070 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14071 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14072 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14073 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14074 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14076 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14078 uint salt_len
= input_len
- 64 - 1;
14080 char *salt_buf
= input_buf
+ 64 + 1;
14082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14088 salt
->salt_len
= salt_len
;
14090 return (PARSER_OK
);
14093 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14095 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14097 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14101 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14104 u64
*digest
= (u64
*) hash_buf
->digest
;
14106 salt_t
*salt
= hash_buf
->salt
;
14108 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14109 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14110 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14111 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14112 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14113 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14114 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14115 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14117 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14119 uint salt_len
= input_len
- 128 - 1;
14121 char *salt_buf
= input_buf
+ 128 + 1;
14123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14125 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14129 salt
->salt_len
= salt_len
;
14131 return (PARSER_OK
);
14134 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14136 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14138 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14140 u32
*digest
= (u32
*) hash_buf
->digest
;
14142 salt_t
*salt
= hash_buf
->salt
;
14144 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14150 char *user_pos
= input_buf
+ 10 + 1;
14152 char *realm_pos
= strchr (user_pos
, '$');
14154 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14156 uint user_len
= realm_pos
- user_pos
;
14158 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14162 char *salt_pos
= strchr (realm_pos
, '$');
14164 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14166 uint realm_len
= salt_pos
- realm_pos
;
14168 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14172 char *data_pos
= strchr (salt_pos
, '$');
14174 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14176 uint salt_len
= data_pos
- salt_pos
;
14178 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14182 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14184 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14190 memcpy (krb5pa
->user
, user_pos
, user_len
);
14191 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14192 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14194 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14196 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14198 const char p0
= data_pos
[i
+ 0];
14199 const char p1
= data_pos
[i
+ 1];
14201 *timestamp_ptr
++ = hex_convert (p1
) << 0
14202 | hex_convert (p0
) << 4;
14205 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14207 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14209 const char p0
= data_pos
[i
+ 0];
14210 const char p1
= data_pos
[i
+ 1];
14212 *checksum_ptr
++ = hex_convert (p1
) << 0
14213 | hex_convert (p0
) << 4;
14217 * copy some data to generic buffers to make sorting happy
14220 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14221 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14222 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14223 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14224 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14225 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14226 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14227 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14228 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14230 salt
->salt_len
= 36;
14232 digest
[0] = krb5pa
->checksum
[0];
14233 digest
[1] = krb5pa
->checksum
[1];
14234 digest
[2] = krb5pa
->checksum
[2];
14235 digest
[3] = krb5pa
->checksum
[3];
14237 return (PARSER_OK
);
14240 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14242 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14244 u32
*digest
= (u32
*) hash_buf
->digest
;
14246 salt_t
*salt
= hash_buf
->salt
;
14252 char *salt_pos
= input_buf
;
14254 char *hash_pos
= strchr (salt_pos
, '$');
14256 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14258 uint salt_len
= hash_pos
- salt_pos
;
14260 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14264 uint hash_len
= input_len
- 1 - salt_len
;
14266 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14274 for (uint i
= 0; i
< salt_len
; i
++)
14276 if (salt_pos
[i
] == ' ') continue;
14281 // SAP user names cannot be longer than 12 characters
14282 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14284 // SAP user name cannot start with ! or ?
14285 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14291 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14293 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14295 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14297 salt
->salt_len
= salt_len
;
14299 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14300 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14304 digest
[0] = byte_swap_32 (digest
[0]);
14305 digest
[1] = byte_swap_32 (digest
[1]);
14307 return (PARSER_OK
);
14310 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14312 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14314 u32
*digest
= (u32
*) hash_buf
->digest
;
14316 salt_t
*salt
= hash_buf
->salt
;
14322 char *salt_pos
= input_buf
;
14324 char *hash_pos
= strchr (salt_pos
, '$');
14326 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14328 uint salt_len
= hash_pos
- salt_pos
;
14330 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14334 uint hash_len
= input_len
- 1 - salt_len
;
14336 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14344 for (uint i
= 0; i
< salt_len
; i
++)
14346 if (salt_pos
[i
] == ' ') continue;
14351 // SAP user names cannot be longer than 12 characters
14352 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14353 // so far nobody complained so we stay with this because it helps in optimization
14354 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14356 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14358 // SAP user name cannot start with ! or ?
14359 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14371 salt
->salt_len
= salt_len
;
14373 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14374 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14375 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14376 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14377 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14379 return (PARSER_OK
);
14382 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14384 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14386 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14388 u64
*digest
= (u64
*) hash_buf
->digest
;
14390 salt_t
*salt
= hash_buf
->salt
;
14392 char *iter_pos
= input_buf
+ 3;
14394 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14396 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14398 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14400 salt
->salt_iter
= salt_iter
;
14402 char *salt_pos
= iter_pos
+ 1;
14406 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14408 salt
->salt_len
= salt_len
;
14410 char *hash_pos
= salt_pos
+ salt_len
;
14412 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14416 char *tmp
= (char *) salt
->salt_buf_pc
;
14418 tmp
[0] = hash_pos
[42];
14422 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14423 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14424 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14425 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14431 return (PARSER_OK
);
14434 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14436 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14438 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14440 u32
*digest
= (u32
*) hash_buf
->digest
;
14442 salt_t
*salt
= hash_buf
->salt
;
14444 char *salt_buf
= input_buf
+ 6;
14446 uint salt_len
= 16;
14448 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14450 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14452 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14454 salt
->salt_len
= salt_len
;
14456 char *hash_pos
= input_buf
+ 6 + 16;
14458 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14459 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14460 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14461 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14462 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14463 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14464 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14465 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14467 return (PARSER_OK
);
14470 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14472 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14474 u32
*digest
= (u32
*) hash_buf
->digest
;
14476 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14477 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14481 return (PARSER_OK
);
14484 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14486 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14488 u32
*digest
= (u32
*) hash_buf
->digest
;
14490 salt_t
*salt
= hash_buf
->salt
;
14492 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14494 char *saltbuf_pos
= input_buf
;
14496 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14498 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14500 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14502 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14503 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14505 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14509 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14511 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14513 char *salt_ptr
= (char *) saltbuf_pos
;
14514 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14519 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14521 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14524 rakp_ptr
[j
] = 0x80;
14526 rakp
->salt_len
= j
;
14528 for (i
= 0; i
< 64; i
++)
14530 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14533 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14534 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14535 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14536 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14537 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14538 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14539 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14540 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14542 salt
->salt_len
= 32; // muss min. 32 haben
14544 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14545 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14546 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14547 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14548 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14550 return (PARSER_OK
);
14553 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14555 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14557 u32
*digest
= (u32
*) hash_buf
->digest
;
14559 salt_t
*salt
= hash_buf
->salt
;
14561 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14563 char *salt_pos
= input_buf
+ 1;
14565 memcpy (salt
->salt_buf
, salt_pos
, 8);
14567 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14568 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14570 salt
->salt_len
= 8;
14572 char *hash_pos
= salt_pos
+ 8;
14574 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14575 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14576 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14577 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14578 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14580 digest
[0] -= SHA1M_A
;
14581 digest
[1] -= SHA1M_B
;
14582 digest
[2] -= SHA1M_C
;
14583 digest
[3] -= SHA1M_D
;
14584 digest
[4] -= SHA1M_E
;
14586 return (PARSER_OK
);
14589 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14591 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14593 u32
*digest
= (u32
*) hash_buf
->digest
;
14595 salt_t
*salt
= hash_buf
->salt
;
14597 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14598 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14599 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14600 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14602 digest
[0] = byte_swap_32 (digest
[0]);
14603 digest
[1] = byte_swap_32 (digest
[1]);
14604 digest
[2] = byte_swap_32 (digest
[2]);
14605 digest
[3] = byte_swap_32 (digest
[3]);
14607 digest
[0] -= MD5M_A
;
14608 digest
[1] -= MD5M_B
;
14609 digest
[2] -= MD5M_C
;
14610 digest
[3] -= MD5M_D
;
14612 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14614 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14616 u32
*salt_buf
= salt
->salt_buf
;
14618 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14619 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14620 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14621 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14623 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14624 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14625 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14626 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14628 salt
->salt_len
= 16 + 1;
14630 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14632 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14634 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14636 return (PARSER_OK
);
14639 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14641 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14643 u32
*digest
= (u32
*) hash_buf
->digest
;
14645 salt_t
*salt
= hash_buf
->salt
;
14647 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14653 char *hashbuf_pos
= input_buf
;
14655 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14657 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14659 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14661 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14665 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14667 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14669 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14671 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14675 char *databuf_pos
= strchr (iteration_pos
, ':');
14677 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14679 const uint iteration_len
= databuf_pos
- iteration_pos
;
14681 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14682 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14684 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14686 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14687 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14693 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14694 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14695 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14696 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14697 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14698 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14699 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14700 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14704 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14706 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14708 const char p0
= saltbuf_pos
[i
+ 0];
14709 const char p1
= saltbuf_pos
[i
+ 1];
14711 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14712 | hex_convert (p0
) << 4;
14715 salt
->salt_buf
[4] = 0x01000000;
14716 salt
->salt_buf
[5] = 0x80;
14718 salt
->salt_len
= saltbuf_len
/ 2;
14722 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14726 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14728 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14730 const char p0
= databuf_pos
[i
+ 0];
14731 const char p1
= databuf_pos
[i
+ 1];
14733 *databuf_ptr
++ = hex_convert (p1
) << 0
14734 | hex_convert (p0
) << 4;
14737 *databuf_ptr
++ = 0x80;
14739 for (uint i
= 0; i
< 512; i
++)
14741 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14744 cloudkey
->data_len
= databuf_len
/ 2;
14746 return (PARSER_OK
);
14749 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14751 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14753 u32
*digest
= (u32
*) hash_buf
->digest
;
14755 salt_t
*salt
= hash_buf
->salt
;
14761 char *hashbuf_pos
= input_buf
;
14763 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14765 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14767 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14769 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14773 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14775 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14777 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14779 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14781 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14785 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14787 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14789 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14791 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14793 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14797 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14799 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14800 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14802 // ok, the plan for this algorithm is the following:
14803 // we have 2 salts here, the domain-name and a random salt
14804 // while both are used in the initial transformation,
14805 // only the random salt is used in the following iterations
14806 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14807 // and one that includes only the real salt (stored into salt_buf[]).
14808 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14810 u8 tmp_buf
[100] = { 0 };
14812 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14814 memcpy (digest
, tmp_buf
, 20);
14816 digest
[0] = byte_swap_32 (digest
[0]);
14817 digest
[1] = byte_swap_32 (digest
[1]);
14818 digest
[2] = byte_swap_32 (digest
[2]);
14819 digest
[3] = byte_swap_32 (digest
[3]);
14820 digest
[4] = byte_swap_32 (digest
[4]);
14824 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14826 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14828 char *len_ptr
= NULL
;
14830 for (uint i
= 0; i
< domainbuf_len
; i
++)
14832 if (salt_buf_pc_ptr
[i
] == '.')
14834 len_ptr
= &salt_buf_pc_ptr
[i
];
14844 salt
->salt_buf_pc
[7] = domainbuf_len
;
14848 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14850 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14852 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14854 salt
->salt_len
= salt_len
;
14858 salt
->salt_iter
= atoi (iteration_pos
);
14860 return (PARSER_OK
);
14863 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14865 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14867 u32
*digest
= (u32
*) hash_buf
->digest
;
14869 salt_t
*salt
= hash_buf
->salt
;
14871 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14872 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14873 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14874 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14875 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14877 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14879 uint salt_len
= input_len
- 40 - 1;
14881 char *salt_buf
= input_buf
+ 40 + 1;
14883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14885 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14887 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14889 salt
->salt_len
= salt_len
;
14891 return (PARSER_OK
);
14894 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14896 const u8 ascii_to_ebcdic
[] =
14898 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14899 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14900 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14901 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14902 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14903 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14904 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14905 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14906 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14907 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14908 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14909 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14910 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14911 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14912 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14913 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14916 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14918 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14920 u32
*digest
= (u32
*) hash_buf
->digest
;
14922 salt_t
*salt
= hash_buf
->salt
;
14924 char *salt_pos
= input_buf
+ 6 + 1;
14926 char *digest_pos
= strchr (salt_pos
, '*');
14928 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14930 uint salt_len
= digest_pos
- salt_pos
;
14932 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14934 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14936 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14940 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14941 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14943 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14945 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14947 salt
->salt_len
= salt_len
;
14949 for (uint i
= 0; i
< salt_len
; i
++)
14951 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14953 for (uint i
= salt_len
; i
< 8; i
++)
14955 salt_buf_pc_ptr
[i
] = 0x40;
14960 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14962 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14963 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14965 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14966 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14968 digest
[0] = byte_swap_32 (digest
[0]);
14969 digest
[1] = byte_swap_32 (digest
[1]);
14971 IP (digest
[0], digest
[1], tt
);
14973 digest
[0] = rotr32 (digest
[0], 29);
14974 digest
[1] = rotr32 (digest
[1], 29);
14978 return (PARSER_OK
);
14981 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14983 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14985 u32
*digest
= (u32
*) hash_buf
->digest
;
14987 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14988 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14989 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14990 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14992 digest
[0] = byte_swap_32 (digest
[0]);
14993 digest
[1] = byte_swap_32 (digest
[1]);
14994 digest
[2] = byte_swap_32 (digest
[2]);
14995 digest
[3] = byte_swap_32 (digest
[3]);
14997 return (PARSER_OK
);
15000 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15002 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15004 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15006 u32
*digest
= (u32
*) hash_buf
->digest
;
15008 salt_t
*salt
= hash_buf
->salt
;
15010 u8 tmp_buf
[120] = { 0 };
15012 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15014 tmp_buf
[3] += -4; // dont ask!
15016 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15018 salt
->salt_len
= 5;
15020 memcpy (digest
, tmp_buf
+ 5, 9);
15022 // yes, only 9 byte are needed to crack, but 10 to display
15024 salt
->salt_buf_pc
[7] = input_buf
[20];
15026 return (PARSER_OK
);
15029 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15031 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15033 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15035 u32
*digest
= (u32
*) hash_buf
->digest
;
15037 salt_t
*salt
= hash_buf
->salt
;
15039 u8 tmp_buf
[120] = { 0 };
15041 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15043 tmp_buf
[3] += -4; // dont ask!
15047 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15049 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)
15053 char tmp_iter_buf
[11] = { 0 };
15055 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15057 tmp_iter_buf
[10] = 0;
15059 salt
->salt_iter
= atoi (tmp_iter_buf
);
15061 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15063 return (PARSER_SALT_ITERATION
);
15066 salt
->salt_iter
--; // first round in init
15068 // 2 additional bytes for display only
15070 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15071 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15075 memcpy (digest
, tmp_buf
+ 28, 8);
15077 digest
[0] = byte_swap_32 (digest
[0]);
15078 digest
[1] = byte_swap_32 (digest
[1]);
15082 return (PARSER_OK
);
15085 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15087 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15089 u32
*digest
= (u32
*) hash_buf
->digest
;
15091 salt_t
*salt
= hash_buf
->salt
;
15093 char *salt_buf_pos
= input_buf
;
15095 char *hash_buf_pos
= salt_buf_pos
+ 6;
15097 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15098 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15099 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15100 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15101 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15102 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15103 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15104 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15106 digest
[0] -= SHA256M_A
;
15107 digest
[1] -= SHA256M_B
;
15108 digest
[2] -= SHA256M_C
;
15109 digest
[3] -= SHA256M_D
;
15110 digest
[4] -= SHA256M_E
;
15111 digest
[5] -= SHA256M_F
;
15112 digest
[6] -= SHA256M_G
;
15113 digest
[7] -= SHA256M_H
;
15115 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15117 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15121 salt
->salt_len
= salt_len
;
15123 return (PARSER_OK
);
15126 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15128 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15130 u32
*digest
= (u32
*) hash_buf
->digest
;
15132 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15134 salt_t
*salt
= hash_buf
->salt
;
15136 char *salt_buf
= input_buf
+ 6;
15138 char *digest_buf
= strchr (salt_buf
, '$');
15140 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15142 uint salt_len
= digest_buf
- salt_buf
;
15144 digest_buf
++; // skip the '$' symbol
15146 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15148 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15150 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15152 salt
->salt_len
= salt_len
;
15154 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15155 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15156 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15157 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15159 digest
[0] = byte_swap_32 (digest
[0]);
15160 digest
[1] = byte_swap_32 (digest
[1]);
15161 digest
[2] = byte_swap_32 (digest
[2]);
15162 digest
[3] = byte_swap_32 (digest
[3]);
15164 digest
[0] -= MD5M_A
;
15165 digest
[1] -= MD5M_B
;
15166 digest
[2] -= MD5M_C
;
15167 digest
[3] -= MD5M_D
;
15169 return (PARSER_OK
);
15172 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15174 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15176 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15178 u32
*digest
= (u32
*) hash_buf
->digest
;
15180 salt_t
*salt
= hash_buf
->salt
;
15182 char *salt_buf
= input_buf
+ 3;
15184 char *digest_buf
= strchr (salt_buf
, '$');
15186 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15188 uint salt_len
= digest_buf
- salt_buf
;
15190 digest_buf
++; // skip the '$' symbol
15192 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15194 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15196 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15198 salt_buf_ptr
[salt_len
] = 0x2d;
15200 salt
->salt_len
= salt_len
+ 1;
15202 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15203 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15204 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15205 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15207 digest
[0] = byte_swap_32 (digest
[0]);
15208 digest
[1] = byte_swap_32 (digest
[1]);
15209 digest
[2] = byte_swap_32 (digest
[2]);
15210 digest
[3] = byte_swap_32 (digest
[3]);
15212 digest
[0] -= MD5M_A
;
15213 digest
[1] -= MD5M_B
;
15214 digest
[2] -= MD5M_C
;
15215 digest
[3] -= MD5M_D
;
15217 return (PARSER_OK
);
15220 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15222 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15224 u32
*digest
= (u32
*) hash_buf
->digest
;
15226 salt_t
*salt
= hash_buf
->salt
;
15228 u8 tmp_buf
[100] = { 0 };
15230 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15232 memcpy (digest
, tmp_buf
, 20);
15234 digest
[0] = byte_swap_32 (digest
[0]);
15235 digest
[1] = byte_swap_32 (digest
[1]);
15236 digest
[2] = byte_swap_32 (digest
[2]);
15237 digest
[3] = byte_swap_32 (digest
[3]);
15238 digest
[4] = byte_swap_32 (digest
[4]);
15240 digest
[0] -= SHA1M_A
;
15241 digest
[1] -= SHA1M_B
;
15242 digest
[2] -= SHA1M_C
;
15243 digest
[3] -= SHA1M_D
;
15244 digest
[4] -= SHA1M_E
;
15246 salt
->salt_buf
[0] = 0x80;
15248 salt
->salt_len
= 0;
15250 return (PARSER_OK
);
15253 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15255 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15257 u32
*digest
= (u32
*) hash_buf
->digest
;
15259 salt_t
*salt
= hash_buf
->salt
;
15261 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15262 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15263 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15264 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
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]);
15271 digest
[0] -= MD5M_A
;
15272 digest
[1] -= MD5M_B
;
15273 digest
[2] -= MD5M_C
;
15274 digest
[3] -= MD5M_D
;
15276 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15278 uint salt_len
= input_len
- 32 - 1;
15280 char *salt_buf
= input_buf
+ 32 + 1;
15282 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15284 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15286 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15289 * add static "salt" part
15292 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15296 salt
->salt_len
= salt_len
;
15298 return (PARSER_OK
);
15301 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15303 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15305 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15307 u32
*digest
= (u32
*) hash_buf
->digest
;
15309 salt_t
*salt
= hash_buf
->salt
;
15311 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15317 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15319 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15321 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15323 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15325 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15329 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15331 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15333 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15335 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15339 char *keybuf_pos
= strchr (keylen_pos
, '$');
15341 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15343 uint keylen_len
= keybuf_pos
- keylen_pos
;
15345 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15349 char *databuf_pos
= strchr (keybuf_pos
, '$');
15351 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15353 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15355 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15359 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15361 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15367 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15368 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15369 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15370 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15372 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15373 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15374 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15375 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15377 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15378 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15379 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15380 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15382 salt
->salt_len
= 16;
15383 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15385 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15387 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15390 return (PARSER_OK
);
15393 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15395 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15397 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15399 u32
*digest
= (u32
*) hash_buf
->digest
;
15401 salt_t
*salt
= hash_buf
->salt
;
15407 // first is the N salt parameter
15409 char *N_pos
= input_buf
+ 6;
15411 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15415 salt
->scrypt_N
= atoi (N_pos
);
15419 char *r_pos
= strchr (N_pos
, ':');
15421 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15425 salt
->scrypt_r
= atoi (r_pos
);
15429 char *p_pos
= strchr (r_pos
, ':');
15431 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15435 salt
->scrypt_p
= atoi (p_pos
);
15439 char *saltbuf_pos
= strchr (p_pos
, ':');
15441 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15445 char *hash_pos
= strchr (saltbuf_pos
, ':');
15447 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15453 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15455 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15457 u8 tmp_buf
[33] = { 0 };
15459 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15461 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15463 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15465 salt
->salt_len
= tmp_len
;
15466 salt
->salt_iter
= 1;
15468 // digest - base64 decode
15470 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15472 tmp_len
= input_len
- (hash_pos
- input_buf
);
15474 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15476 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15478 memcpy (digest
, tmp_buf
, 32);
15480 return (PARSER_OK
);
15483 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15485 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15487 u32
*digest
= (u32
*) hash_buf
->digest
;
15489 salt_t
*salt
= hash_buf
->salt
;
15495 char decrypted
[76] = { 0 }; // iv + hash
15497 juniper_decrypt_hash (input_buf
, decrypted
);
15499 char *md5crypt_hash
= decrypted
+ 12;
15501 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15503 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15505 char *salt_pos
= md5crypt_hash
+ 3;
15507 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15509 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15511 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15515 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15517 return (PARSER_OK
);
15520 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15522 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15524 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15526 u32
*digest
= (u32
*) hash_buf
->digest
;
15528 salt_t
*salt
= hash_buf
->salt
;
15530 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15536 // first is *raw* salt
15538 char *salt_pos
= input_buf
+ 3;
15540 char *hash_pos
= strchr (salt_pos
, '$');
15542 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15544 uint salt_len
= hash_pos
- salt_pos
;
15546 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15550 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15552 memcpy (salt_buf_ptr
, salt_pos
, 14);
15554 salt_buf_ptr
[17] = 0x01;
15555 salt_buf_ptr
[18] = 0x80;
15557 // add some stuff to normal salt to make sorted happy
15559 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15560 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15561 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15562 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15564 salt
->salt_len
= salt_len
;
15565 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15567 // base64 decode hash
15569 u8 tmp_buf
[100] = { 0 };
15571 uint hash_len
= input_len
- 3 - salt_len
- 1;
15573 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15575 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15577 memcpy (digest
, tmp_buf
, 32);
15579 digest
[0] = byte_swap_32 (digest
[0]);
15580 digest
[1] = byte_swap_32 (digest
[1]);
15581 digest
[2] = byte_swap_32 (digest
[2]);
15582 digest
[3] = byte_swap_32 (digest
[3]);
15583 digest
[4] = byte_swap_32 (digest
[4]);
15584 digest
[5] = byte_swap_32 (digest
[5]);
15585 digest
[6] = byte_swap_32 (digest
[6]);
15586 digest
[7] = byte_swap_32 (digest
[7]);
15588 return (PARSER_OK
);
15591 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15593 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15595 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15597 u32
*digest
= (u32
*) hash_buf
->digest
;
15599 salt_t
*salt
= hash_buf
->salt
;
15605 // first is *raw* salt
15607 char *salt_pos
= input_buf
+ 3;
15609 char *hash_pos
= strchr (salt_pos
, '$');
15611 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15613 uint salt_len
= hash_pos
- salt_pos
;
15615 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15617 salt
->salt_len
= salt_len
;
15620 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15622 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15623 salt_buf_ptr
[salt_len
] = 0;
15625 // base64 decode hash
15627 u8 tmp_buf
[100] = { 0 };
15629 uint hash_len
= input_len
- 3 - salt_len
- 1;
15631 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15633 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15635 memcpy (digest
, tmp_buf
, 32);
15638 salt
->scrypt_N
= 16384;
15639 salt
->scrypt_r
= 1;
15640 salt
->scrypt_p
= 1;
15641 salt
->salt_iter
= 1;
15643 return (PARSER_OK
);
15646 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15648 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15650 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15652 u32
*digest
= (u32
*) hash_buf
->digest
;
15654 salt_t
*salt
= hash_buf
->salt
;
15656 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15662 char *version_pos
= input_buf
+ 8 + 1;
15664 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15666 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15668 u32 version_len
= verifierHashSize_pos
- version_pos
;
15670 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15672 verifierHashSize_pos
++;
15674 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15676 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15678 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15680 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15684 char *saltSize_pos
= strchr (keySize_pos
, '*');
15686 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15688 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15690 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15694 char *osalt_pos
= strchr (saltSize_pos
, '*');
15696 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15698 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15700 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15704 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15706 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15708 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15710 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15712 encryptedVerifier_pos
++;
15714 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15716 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15718 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15720 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15722 encryptedVerifierHash_pos
++;
15724 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;
15726 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15728 const uint version
= atoi (version_pos
);
15730 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15732 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15734 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15736 const uint keySize
= atoi (keySize_pos
);
15738 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15740 office2007
->keySize
= keySize
;
15742 const uint saltSize
= atoi (saltSize_pos
);
15744 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15750 salt
->salt_len
= 16;
15751 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15753 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15754 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15755 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15756 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15762 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15763 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15764 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15765 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15767 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15768 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15769 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15770 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15771 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15777 digest
[0] = office2007
->encryptedVerifierHash
[0];
15778 digest
[1] = office2007
->encryptedVerifierHash
[1];
15779 digest
[2] = office2007
->encryptedVerifierHash
[2];
15780 digest
[3] = office2007
->encryptedVerifierHash
[3];
15782 return (PARSER_OK
);
15785 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15787 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15789 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15791 u32
*digest
= (u32
*) hash_buf
->digest
;
15793 salt_t
*salt
= hash_buf
->salt
;
15795 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15801 char *version_pos
= input_buf
+ 8 + 1;
15803 char *spinCount_pos
= strchr (version_pos
, '*');
15805 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15807 u32 version_len
= spinCount_pos
- version_pos
;
15809 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15813 char *keySize_pos
= strchr (spinCount_pos
, '*');
15815 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15817 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15819 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15823 char *saltSize_pos
= strchr (keySize_pos
, '*');
15825 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15827 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15829 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15833 char *osalt_pos
= strchr (saltSize_pos
, '*');
15835 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15837 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15839 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15843 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15845 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15847 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15849 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15851 encryptedVerifier_pos
++;
15853 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15855 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15857 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15859 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15861 encryptedVerifierHash_pos
++;
15863 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;
15865 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15867 const uint version
= atoi (version_pos
);
15869 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15871 const uint spinCount
= atoi (spinCount_pos
);
15873 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15875 const uint keySize
= atoi (keySize_pos
);
15877 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15879 const uint saltSize
= atoi (saltSize_pos
);
15881 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15887 salt
->salt_len
= 16;
15888 salt
->salt_iter
= spinCount
;
15890 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15891 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15892 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15893 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15899 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15900 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15901 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15902 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15904 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15905 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15906 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15907 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15908 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15909 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15910 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15911 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15917 digest
[0] = office2010
->encryptedVerifierHash
[0];
15918 digest
[1] = office2010
->encryptedVerifierHash
[1];
15919 digest
[2] = office2010
->encryptedVerifierHash
[2];
15920 digest
[3] = office2010
->encryptedVerifierHash
[3];
15922 return (PARSER_OK
);
15925 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15927 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15929 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15931 u32
*digest
= (u32
*) hash_buf
->digest
;
15933 salt_t
*salt
= hash_buf
->salt
;
15935 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15941 char *version_pos
= input_buf
+ 8 + 1;
15943 char *spinCount_pos
= strchr (version_pos
, '*');
15945 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15947 u32 version_len
= spinCount_pos
- version_pos
;
15949 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15953 char *keySize_pos
= strchr (spinCount_pos
, '*');
15955 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15957 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15959 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15963 char *saltSize_pos
= strchr (keySize_pos
, '*');
15965 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15967 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15969 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15973 char *osalt_pos
= strchr (saltSize_pos
, '*');
15975 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15977 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15979 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15983 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15985 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15987 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15989 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15991 encryptedVerifier_pos
++;
15993 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15995 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15997 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15999 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16001 encryptedVerifierHash_pos
++;
16003 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;
16005 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16007 const uint version
= atoi (version_pos
);
16009 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16011 const uint spinCount
= atoi (spinCount_pos
);
16013 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16015 const uint keySize
= atoi (keySize_pos
);
16017 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16019 const uint saltSize
= atoi (saltSize_pos
);
16021 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16027 salt
->salt_len
= 16;
16028 salt
->salt_iter
= spinCount
;
16030 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16031 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16032 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16033 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16039 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16040 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16041 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16042 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16044 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16045 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16046 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16047 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16048 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16049 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16050 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16051 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16057 digest
[0] = office2013
->encryptedVerifierHash
[0];
16058 digest
[1] = office2013
->encryptedVerifierHash
[1];
16059 digest
[2] = office2013
->encryptedVerifierHash
[2];
16060 digest
[3] = office2013
->encryptedVerifierHash
[3];
16062 return (PARSER_OK
);
16065 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16067 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16069 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16071 u32
*digest
= (u32
*) hash_buf
->digest
;
16073 salt_t
*salt
= hash_buf
->salt
;
16075 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16081 char *version_pos
= input_buf
+ 11;
16083 char *osalt_pos
= strchr (version_pos
, '*');
16085 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16087 u32 version_len
= osalt_pos
- version_pos
;
16089 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16093 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16095 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16097 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16099 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16101 encryptedVerifier_pos
++;
16103 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16105 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16107 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16109 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16111 encryptedVerifierHash_pos
++;
16113 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16115 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16117 const uint version
= *version_pos
- 0x30;
16119 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16125 oldoffice01
->version
= version
;
16127 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16128 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16129 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16130 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16132 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16133 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16134 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16135 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16137 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16138 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16139 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16140 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16142 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16143 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16144 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16145 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16151 salt
->salt_len
= 16;
16153 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16154 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16155 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16156 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16158 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16159 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16160 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16161 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16163 // this is a workaround as office produces multiple documents with the same salt
16165 salt
->salt_len
+= 32;
16167 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16168 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16169 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16170 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16171 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16172 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16173 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16174 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16180 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16181 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16182 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16183 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16185 return (PARSER_OK
);
16188 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16190 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16193 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16195 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16197 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16199 u32
*digest
= (u32
*) hash_buf
->digest
;
16201 salt_t
*salt
= hash_buf
->salt
;
16203 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16209 char *version_pos
= input_buf
+ 11;
16211 char *osalt_pos
= strchr (version_pos
, '*');
16213 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16215 u32 version_len
= osalt_pos
- version_pos
;
16217 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16221 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16223 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16225 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16227 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16229 encryptedVerifier_pos
++;
16231 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16233 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16235 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16237 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16239 encryptedVerifierHash_pos
++;
16241 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16243 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16245 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16247 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16251 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16253 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16255 const uint version
= *version_pos
- 0x30;
16257 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16263 oldoffice01
->version
= version
;
16265 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16266 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16267 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16268 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16270 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16271 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16272 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16273 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16275 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16276 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16277 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16278 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16280 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16281 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16282 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16283 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16285 oldoffice01
->rc4key
[1] = 0;
16286 oldoffice01
->rc4key
[0] = 0;
16288 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16289 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16290 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16291 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16292 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16293 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16294 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16295 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16296 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16297 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16299 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16300 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16306 salt
->salt_len
= 16;
16308 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16309 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16310 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16311 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16313 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16314 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16315 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16316 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16318 // this is a workaround as office produces multiple documents with the same salt
16320 salt
->salt_len
+= 32;
16322 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16323 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16324 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16325 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16326 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16327 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16328 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16329 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16335 digest
[0] = oldoffice01
->rc4key
[0];
16336 digest
[1] = oldoffice01
->rc4key
[1];
16340 return (PARSER_OK
);
16343 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16345 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16347 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16349 u32
*digest
= (u32
*) hash_buf
->digest
;
16351 salt_t
*salt
= hash_buf
->salt
;
16353 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16359 char *version_pos
= input_buf
+ 11;
16361 char *osalt_pos
= strchr (version_pos
, '*');
16363 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16365 u32 version_len
= osalt_pos
- version_pos
;
16367 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16371 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16373 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16375 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16377 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16379 encryptedVerifier_pos
++;
16381 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16383 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16385 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16387 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16389 encryptedVerifierHash_pos
++;
16391 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16393 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16395 const uint version
= *version_pos
- 0x30;
16397 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16403 oldoffice34
->version
= version
;
16405 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16406 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16407 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16408 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16410 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16411 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16412 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16413 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16415 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16416 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16417 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16418 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16419 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16421 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16422 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16423 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16424 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16425 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16431 salt
->salt_len
= 16;
16433 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16434 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16435 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16436 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16438 // this is a workaround as office produces multiple documents with the same salt
16440 salt
->salt_len
+= 32;
16442 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16443 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16444 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16445 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16446 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16447 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16448 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16449 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16455 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16456 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16457 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16458 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16460 return (PARSER_OK
);
16463 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16465 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16467 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16470 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16472 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16474 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16476 u32
*digest
= (u32
*) hash_buf
->digest
;
16478 salt_t
*salt
= hash_buf
->salt
;
16480 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16486 char *version_pos
= input_buf
+ 11;
16488 char *osalt_pos
= strchr (version_pos
, '*');
16490 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16492 u32 version_len
= osalt_pos
- version_pos
;
16494 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16498 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16500 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16502 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16504 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16506 encryptedVerifier_pos
++;
16508 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16510 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16512 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16514 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16516 encryptedVerifierHash_pos
++;
16518 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16520 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16522 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16524 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16528 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16530 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16532 const uint version
= *version_pos
- 0x30;
16534 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16540 oldoffice34
->version
= version
;
16542 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16543 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16544 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16545 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16547 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16548 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16549 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16550 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16552 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16553 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16554 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16555 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16556 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16558 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16559 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16560 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16561 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16562 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16564 oldoffice34
->rc4key
[1] = 0;
16565 oldoffice34
->rc4key
[0] = 0;
16567 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16568 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16569 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16570 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16571 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16572 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16573 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16574 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16575 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16576 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16578 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16579 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16585 salt
->salt_len
= 16;
16587 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16588 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16589 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16590 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16592 // this is a workaround as office produces multiple documents with the same salt
16594 salt
->salt_len
+= 32;
16596 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16597 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16598 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16599 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16600 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16601 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16602 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16603 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16609 digest
[0] = oldoffice34
->rc4key
[0];
16610 digest
[1] = oldoffice34
->rc4key
[1];
16614 return (PARSER_OK
);
16617 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16619 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16621 u32
*digest
= (u32
*) hash_buf
->digest
;
16623 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16624 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16625 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16626 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16628 digest
[0] = byte_swap_32 (digest
[0]);
16629 digest
[1] = byte_swap_32 (digest
[1]);
16630 digest
[2] = byte_swap_32 (digest
[2]);
16631 digest
[3] = byte_swap_32 (digest
[3]);
16633 return (PARSER_OK
);
16636 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16638 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16640 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16642 u32
*digest
= (u32
*) hash_buf
->digest
;
16644 salt_t
*salt
= hash_buf
->salt
;
16646 char *signature_pos
= input_buf
;
16648 char *salt_pos
= strchr (signature_pos
, '$');
16650 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16652 u32 signature_len
= salt_pos
- signature_pos
;
16654 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16658 char *hash_pos
= strchr (salt_pos
, '$');
16660 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16662 u32 salt_len
= hash_pos
- salt_pos
;
16664 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16668 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16670 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16672 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16673 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16674 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16675 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16676 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16678 digest
[0] -= SHA1M_A
;
16679 digest
[1] -= SHA1M_B
;
16680 digest
[2] -= SHA1M_C
;
16681 digest
[3] -= SHA1M_D
;
16682 digest
[4] -= SHA1M_E
;
16684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16686 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16688 salt
->salt_len
= salt_len
;
16690 return (PARSER_OK
);
16693 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16695 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16697 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16699 u32
*digest
= (u32
*) hash_buf
->digest
;
16701 salt_t
*salt
= hash_buf
->salt
;
16703 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16709 char *iter_pos
= input_buf
+ 14;
16711 const int iter
= atoi (iter_pos
);
16713 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16715 salt
->salt_iter
= iter
- 1;
16717 char *salt_pos
= strchr (iter_pos
, '$');
16719 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16723 char *hash_pos
= strchr (salt_pos
, '$');
16725 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16727 const uint salt_len
= hash_pos
- salt_pos
;
16731 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16733 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16735 salt
->salt_len
= salt_len
;
16737 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16738 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16740 // add some stuff to normal salt to make sorted happy
16742 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16743 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16744 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16745 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16746 salt
->salt_buf
[4] = salt
->salt_iter
;
16748 // base64 decode hash
16750 u8 tmp_buf
[100] = { 0 };
16752 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16754 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16756 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16758 memcpy (digest
, tmp_buf
, 32);
16760 digest
[0] = byte_swap_32 (digest
[0]);
16761 digest
[1] = byte_swap_32 (digest
[1]);
16762 digest
[2] = byte_swap_32 (digest
[2]);
16763 digest
[3] = byte_swap_32 (digest
[3]);
16764 digest
[4] = byte_swap_32 (digest
[4]);
16765 digest
[5] = byte_swap_32 (digest
[5]);
16766 digest
[6] = byte_swap_32 (digest
[6]);
16767 digest
[7] = byte_swap_32 (digest
[7]);
16769 return (PARSER_OK
);
16772 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16774 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16776 u32
*digest
= (u32
*) hash_buf
->digest
;
16778 salt_t
*salt
= hash_buf
->salt
;
16780 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16781 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16785 digest
[0] = byte_swap_32 (digest
[0]);
16786 digest
[1] = byte_swap_32 (digest
[1]);
16788 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16789 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16790 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16792 char iter_c
= input_buf
[17];
16793 char iter_d
= input_buf
[19];
16795 // atm only defaults, let's see if there's more request
16796 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16797 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16799 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16801 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16802 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16803 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16804 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16806 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16807 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16808 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16809 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16811 salt
->salt_len
= 16;
16813 return (PARSER_OK
);
16816 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16818 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16820 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16822 u32
*digest
= (u32
*) hash_buf
->digest
;
16824 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16826 salt_t
*salt
= hash_buf
->salt
;
16828 char *salt_pos
= input_buf
+ 10;
16830 char *hash_pos
= strchr (salt_pos
, '$');
16832 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16834 uint salt_len
= hash_pos
- salt_pos
;
16838 uint hash_len
= input_len
- 10 - salt_len
- 1;
16840 // base64 decode salt
16842 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16844 u8 tmp_buf
[100] = { 0 };
16846 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16848 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16850 tmp_buf
[salt_len
] = 0x80;
16852 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16854 salt
->salt_len
= salt_len
;
16856 // base64 decode hash
16858 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16860 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16862 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16864 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16866 uint user_len
= hash_len
- 32;
16868 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16870 user_len
--; // skip the trailing space
16872 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16873 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16874 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16875 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16877 digest
[0] = byte_swap_32 (digest
[0]);
16878 digest
[1] = byte_swap_32 (digest
[1]);
16879 digest
[2] = byte_swap_32 (digest
[2]);
16880 digest
[3] = byte_swap_32 (digest
[3]);
16882 // store username for host only (output hash if cracked)
16884 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16885 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16887 return (PARSER_OK
);
16890 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16892 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16894 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16896 u32
*digest
= (u32
*) hash_buf
->digest
;
16898 salt_t
*salt
= hash_buf
->salt
;
16900 char *iter_pos
= input_buf
+ 10;
16902 u32 iter
= atoi (iter_pos
);
16906 return (PARSER_SALT_ITERATION
);
16909 iter
--; // first iteration is special
16911 salt
->salt_iter
= iter
;
16913 char *base64_pos
= strchr (iter_pos
, '}');
16915 if (base64_pos
== NULL
)
16917 return (PARSER_SIGNATURE_UNMATCHED
);
16922 // base64 decode salt
16924 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16926 u8 tmp_buf
[100] = { 0 };
16928 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16930 if (decoded_len
< 24)
16932 return (PARSER_SALT_LENGTH
);
16937 uint salt_len
= decoded_len
- 20;
16939 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16940 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16942 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16944 salt
->salt_len
= salt_len
;
16948 u32
*digest_ptr
= (u32
*) tmp_buf
;
16950 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16951 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16952 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16953 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16954 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16956 return (PARSER_OK
);
16959 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16961 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16963 u32
*digest
= (u32
*) hash_buf
->digest
;
16965 salt_t
*salt
= hash_buf
->salt
;
16967 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16968 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16969 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16970 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16971 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16973 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16975 uint salt_len
= input_len
- 40 - 1;
16977 char *salt_buf
= input_buf
+ 40 + 1;
16979 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16981 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16983 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16985 salt
->salt_len
= salt_len
;
16987 return (PARSER_OK
);
16990 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16992 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16994 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16996 u32
*digest
= (u32
*) hash_buf
->digest
;
16998 salt_t
*salt
= hash_buf
->salt
;
17000 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17006 char *V_pos
= input_buf
+ 5;
17008 char *R_pos
= strchr (V_pos
, '*');
17010 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17012 u32 V_len
= R_pos
- V_pos
;
17016 char *bits_pos
= strchr (R_pos
, '*');
17018 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17020 u32 R_len
= bits_pos
- R_pos
;
17024 char *P_pos
= strchr (bits_pos
, '*');
17026 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17028 u32 bits_len
= P_pos
- bits_pos
;
17032 char *enc_md_pos
= strchr (P_pos
, '*');
17034 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17036 u32 P_len
= enc_md_pos
- P_pos
;
17040 char *id_len_pos
= strchr (enc_md_pos
, '*');
17042 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17044 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17048 char *id_buf_pos
= strchr (id_len_pos
, '*');
17050 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17056 char *u_len_pos
= strchr (id_buf_pos
, '*');
17058 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17060 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17062 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17066 char *u_buf_pos
= strchr (u_len_pos
, '*');
17068 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17074 char *o_len_pos
= strchr (u_buf_pos
, '*');
17076 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17078 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17080 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17084 char *o_buf_pos
= strchr (o_len_pos
, '*');
17086 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17088 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17092 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;
17094 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17098 const int V
= atoi (V_pos
);
17099 const int R
= atoi (R_pos
);
17100 const int P
= atoi (P_pos
);
17102 if (V
!= 1) return (PARSER_SALT_VALUE
);
17103 if (R
!= 2) return (PARSER_SALT_VALUE
);
17105 const int enc_md
= atoi (enc_md_pos
);
17107 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17109 const int id_len
= atoi (id_len_pos
);
17110 const int u_len
= atoi (u_len_pos
);
17111 const int o_len
= atoi (o_len_pos
);
17113 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17114 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17115 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17117 const int bits
= atoi (bits_pos
);
17119 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17121 // copy data to esalt
17127 pdf
->enc_md
= enc_md
;
17129 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17130 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17131 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17132 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17133 pdf
->id_len
= id_len
;
17135 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17136 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17137 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17138 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17139 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17140 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17141 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17142 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17143 pdf
->u_len
= u_len
;
17145 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17146 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17147 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17148 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17149 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17150 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17151 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17152 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17153 pdf
->o_len
= o_len
;
17155 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17156 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17157 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17158 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17160 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17161 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17162 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17163 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17164 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17165 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17166 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17167 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17169 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17170 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17171 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17172 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17173 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17174 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17175 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17176 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17178 // we use ID for salt, maybe needs to change, we will see...
17180 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17181 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17182 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17183 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17184 salt
->salt_len
= pdf
->id_len
;
17186 digest
[0] = pdf
->u_buf
[0];
17187 digest
[1] = pdf
->u_buf
[1];
17188 digest
[2] = pdf
->u_buf
[2];
17189 digest
[3] = pdf
->u_buf
[3];
17191 return (PARSER_OK
);
17194 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17196 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17199 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17201 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17203 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17205 u32
*digest
= (u32
*) hash_buf
->digest
;
17207 salt_t
*salt
= hash_buf
->salt
;
17209 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17215 char *V_pos
= input_buf
+ 5;
17217 char *R_pos
= strchr (V_pos
, '*');
17219 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17221 u32 V_len
= R_pos
- V_pos
;
17225 char *bits_pos
= strchr (R_pos
, '*');
17227 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17229 u32 R_len
= bits_pos
- R_pos
;
17233 char *P_pos
= strchr (bits_pos
, '*');
17235 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17237 u32 bits_len
= P_pos
- bits_pos
;
17241 char *enc_md_pos
= strchr (P_pos
, '*');
17243 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17245 u32 P_len
= enc_md_pos
- P_pos
;
17249 char *id_len_pos
= strchr (enc_md_pos
, '*');
17251 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17257 char *id_buf_pos
= strchr (id_len_pos
, '*');
17259 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17265 char *u_len_pos
= strchr (id_buf_pos
, '*');
17267 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17271 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17275 char *u_buf_pos
= strchr (u_len_pos
, '*');
17277 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17279 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17283 char *o_len_pos
= strchr (u_buf_pos
, '*');
17285 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17287 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17289 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17293 char *o_buf_pos
= strchr (o_len_pos
, '*');
17295 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17297 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17301 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17303 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17305 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17307 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17311 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;
17313 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17317 const int V
= atoi (V_pos
);
17318 const int R
= atoi (R_pos
);
17319 const int P
= atoi (P_pos
);
17321 if (V
!= 1) return (PARSER_SALT_VALUE
);
17322 if (R
!= 2) return (PARSER_SALT_VALUE
);
17324 const int enc_md
= atoi (enc_md_pos
);
17326 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17328 const int id_len
= atoi (id_len_pos
);
17329 const int u_len
= atoi (u_len_pos
);
17330 const int o_len
= atoi (o_len_pos
);
17332 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17333 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17334 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17336 const int bits
= atoi (bits_pos
);
17338 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17340 // copy data to esalt
17346 pdf
->enc_md
= enc_md
;
17348 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17349 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17350 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17351 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17352 pdf
->id_len
= id_len
;
17354 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17355 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17356 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17357 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17358 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17359 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17360 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17361 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17362 pdf
->u_len
= u_len
;
17364 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17365 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17366 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17367 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17368 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17369 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17370 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17371 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17372 pdf
->o_len
= o_len
;
17374 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17375 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17376 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17377 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17379 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17380 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17381 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17382 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17383 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17384 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17385 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17386 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17388 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17389 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17390 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17391 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17392 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17393 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17394 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17395 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17397 pdf
->rc4key
[1] = 0;
17398 pdf
->rc4key
[0] = 0;
17400 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17401 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17402 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17403 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17404 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17405 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17406 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17407 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17408 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17409 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17411 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17412 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17414 // we use ID for salt, maybe needs to change, we will see...
17416 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17417 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17418 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17419 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17420 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17421 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17422 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17423 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17424 salt
->salt_len
= pdf
->id_len
+ 16;
17426 digest
[0] = pdf
->rc4key
[0];
17427 digest
[1] = pdf
->rc4key
[1];
17431 return (PARSER_OK
);
17434 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17436 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17438 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17440 u32
*digest
= (u32
*) hash_buf
->digest
;
17442 salt_t
*salt
= hash_buf
->salt
;
17444 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17450 char *V_pos
= input_buf
+ 5;
17452 char *R_pos
= strchr (V_pos
, '*');
17454 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17456 u32 V_len
= R_pos
- V_pos
;
17460 char *bits_pos
= strchr (R_pos
, '*');
17462 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17464 u32 R_len
= bits_pos
- R_pos
;
17468 char *P_pos
= strchr (bits_pos
, '*');
17470 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17472 u32 bits_len
= P_pos
- bits_pos
;
17476 char *enc_md_pos
= strchr (P_pos
, '*');
17478 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17480 u32 P_len
= enc_md_pos
- P_pos
;
17484 char *id_len_pos
= strchr (enc_md_pos
, '*');
17486 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17488 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17492 char *id_buf_pos
= strchr (id_len_pos
, '*');
17494 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17496 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17500 char *u_len_pos
= strchr (id_buf_pos
, '*');
17502 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17504 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17506 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17510 char *u_buf_pos
= strchr (u_len_pos
, '*');
17512 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17514 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17518 char *o_len_pos
= strchr (u_buf_pos
, '*');
17520 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17522 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17524 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17528 char *o_buf_pos
= strchr (o_len_pos
, '*');
17530 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17532 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17536 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;
17538 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17542 const int V
= atoi (V_pos
);
17543 const int R
= atoi (R_pos
);
17544 const int P
= atoi (P_pos
);
17548 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17549 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17551 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17553 const int id_len
= atoi (id_len_pos
);
17554 const int u_len
= atoi (u_len_pos
);
17555 const int o_len
= atoi (o_len_pos
);
17557 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17559 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17560 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17562 const int bits
= atoi (bits_pos
);
17564 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17570 enc_md
= atoi (enc_md_pos
);
17573 // copy data to esalt
17579 pdf
->enc_md
= enc_md
;
17581 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17582 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17583 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17584 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17588 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17589 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17590 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17591 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17594 pdf
->id_len
= id_len
;
17596 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17597 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17598 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17599 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17600 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17601 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17602 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17603 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17604 pdf
->u_len
= u_len
;
17606 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17607 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17608 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17609 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17610 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17611 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17612 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17613 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17614 pdf
->o_len
= o_len
;
17616 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17617 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17618 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17619 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17623 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17624 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17625 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17626 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17629 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17630 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17631 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17632 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17633 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17634 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17635 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17636 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17638 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17639 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17640 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17641 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17642 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17643 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17644 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17645 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17647 // precompute rc4 data for later use
17663 uint salt_pc_block
[32] = { 0 };
17665 char *salt_pc_ptr
= (char *) salt_pc_block
;
17667 memcpy (salt_pc_ptr
, padding
, 32);
17668 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17670 uint salt_pc_digest
[4] = { 0 };
17672 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17674 pdf
->rc4data
[0] = salt_pc_digest
[0];
17675 pdf
->rc4data
[1] = salt_pc_digest
[1];
17677 // we use ID for salt, maybe needs to change, we will see...
17679 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17680 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17681 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17682 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17683 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17684 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17685 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17686 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17687 salt
->salt_len
= pdf
->id_len
+ 16;
17689 salt
->salt_iter
= ROUNDS_PDF14
;
17691 digest
[0] = pdf
->u_buf
[0];
17692 digest
[1] = pdf
->u_buf
[1];
17696 return (PARSER_OK
);
17699 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17701 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17703 if (ret
!= PARSER_OK
)
17708 u32
*digest
= (u32
*) hash_buf
->digest
;
17710 salt_t
*salt
= hash_buf
->salt
;
17712 digest
[0] -= SHA256M_A
;
17713 digest
[1] -= SHA256M_B
;
17714 digest
[2] -= SHA256M_C
;
17715 digest
[3] -= SHA256M_D
;
17716 digest
[4] -= SHA256M_E
;
17717 digest
[5] -= SHA256M_F
;
17718 digest
[6] -= SHA256M_G
;
17719 digest
[7] -= SHA256M_H
;
17721 salt
->salt_buf
[2] = 0x80;
17723 return (PARSER_OK
);
17726 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17728 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17730 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17732 u32
*digest
= (u32
*) hash_buf
->digest
;
17734 salt_t
*salt
= hash_buf
->salt
;
17736 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17742 char *V_pos
= input_buf
+ 5;
17744 char *R_pos
= strchr (V_pos
, '*');
17746 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17748 u32 V_len
= R_pos
- V_pos
;
17752 char *bits_pos
= strchr (R_pos
, '*');
17754 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17756 u32 R_len
= bits_pos
- R_pos
;
17760 char *P_pos
= strchr (bits_pos
, '*');
17762 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17764 u32 bits_len
= P_pos
- bits_pos
;
17768 char *enc_md_pos
= strchr (P_pos
, '*');
17770 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17772 u32 P_len
= enc_md_pos
- P_pos
;
17776 char *id_len_pos
= strchr (enc_md_pos
, '*');
17778 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17780 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17784 char *id_buf_pos
= strchr (id_len_pos
, '*');
17786 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17788 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17792 char *u_len_pos
= strchr (id_buf_pos
, '*');
17794 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17796 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17800 char *u_buf_pos
= strchr (u_len_pos
, '*');
17802 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17804 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17808 char *o_len_pos
= strchr (u_buf_pos
, '*');
17810 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17812 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17816 char *o_buf_pos
= strchr (o_len_pos
, '*');
17818 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17820 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17824 char *last
= strchr (o_buf_pos
, '*');
17826 if (last
== NULL
) last
= input_buf
+ input_len
;
17828 u32 o_buf_len
= last
- o_buf_pos
;
17832 const int V
= atoi (V_pos
);
17833 const int R
= atoi (R_pos
);
17837 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17838 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17840 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17842 const int bits
= atoi (bits_pos
);
17844 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17846 int enc_md
= atoi (enc_md_pos
);
17848 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17850 const uint id_len
= atoi (id_len_pos
);
17851 const uint u_len
= atoi (u_len_pos
);
17852 const uint o_len
= atoi (o_len_pos
);
17854 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17855 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17856 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17857 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17858 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17859 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17860 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17861 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17863 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17864 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17865 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17867 // copy data to esalt
17869 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17871 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17873 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17876 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17877 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17879 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17880 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17882 salt
->salt_len
= 8;
17883 salt
->salt_iter
= ROUNDS_PDF17L8
;
17885 digest
[0] = pdf
->u_buf
[0];
17886 digest
[1] = pdf
->u_buf
[1];
17887 digest
[2] = pdf
->u_buf
[2];
17888 digest
[3] = pdf
->u_buf
[3];
17889 digest
[4] = pdf
->u_buf
[4];
17890 digest
[5] = pdf
->u_buf
[5];
17891 digest
[6] = pdf
->u_buf
[6];
17892 digest
[7] = pdf
->u_buf
[7];
17894 return (PARSER_OK
);
17897 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17899 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17901 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17903 u32
*digest
= (u32
*) hash_buf
->digest
;
17905 salt_t
*salt
= hash_buf
->salt
;
17907 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17915 char *iter_pos
= input_buf
+ 7;
17917 u32 iter
= atoi (iter_pos
);
17919 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17920 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17922 // first is *raw* salt
17924 char *salt_pos
= strchr (iter_pos
, ':');
17926 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17930 char *hash_pos
= strchr (salt_pos
, ':');
17932 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17934 u32 salt_len
= hash_pos
- salt_pos
;
17936 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17940 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17942 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17946 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17948 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17950 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17952 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17953 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17955 salt
->salt_len
= salt_len
;
17956 salt
->salt_iter
= iter
- 1;
17960 u8 tmp_buf
[100] = { 0 };
17962 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17964 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17966 memcpy (digest
, tmp_buf
, 16);
17968 digest
[0] = byte_swap_32 (digest
[0]);
17969 digest
[1] = byte_swap_32 (digest
[1]);
17970 digest
[2] = byte_swap_32 (digest
[2]);
17971 digest
[3] = byte_swap_32 (digest
[3]);
17973 // add some stuff to normal salt to make sorted happy
17975 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17976 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17977 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17978 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17979 salt
->salt_buf
[4] = salt
->salt_iter
;
17981 return (PARSER_OK
);
17984 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17986 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17988 u32
*digest
= (u32
*) hash_buf
->digest
;
17990 salt_t
*salt
= hash_buf
->salt
;
17992 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17993 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17994 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17995 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17997 digest
[0] = byte_swap_32 (digest
[0]);
17998 digest
[1] = byte_swap_32 (digest
[1]);
17999 digest
[2] = byte_swap_32 (digest
[2]);
18000 digest
[3] = byte_swap_32 (digest
[3]);
18002 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18004 uint salt_len
= input_len
- 32 - 1;
18006 char *salt_buf
= input_buf
+ 32 + 1;
18008 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18010 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18012 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18014 salt
->salt_len
= salt_len
;
18016 return (PARSER_OK
);
18019 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18021 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18023 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18025 u32
*digest
= (u32
*) hash_buf
->digest
;
18027 salt_t
*salt
= hash_buf
->salt
;
18029 char *user_pos
= input_buf
+ 10;
18031 char *salt_pos
= strchr (user_pos
, '*');
18033 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18037 char *hash_pos
= strchr (salt_pos
, '*');
18041 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18043 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18045 uint user_len
= salt_pos
- user_pos
- 1;
18047 uint salt_len
= hash_pos
- salt_pos
- 1;
18049 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18055 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18056 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18057 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18058 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18060 digest
[0] = byte_swap_32 (digest
[0]);
18061 digest
[1] = byte_swap_32 (digest
[1]);
18062 digest
[2] = byte_swap_32 (digest
[2]);
18063 digest
[3] = byte_swap_32 (digest
[3]);
18065 digest
[0] -= MD5M_A
;
18066 digest
[1] -= MD5M_B
;
18067 digest
[2] -= MD5M_C
;
18068 digest
[3] -= MD5M_D
;
18074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18076 // first 4 bytes are the "challenge"
18078 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18079 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18080 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18081 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18083 // append the user name
18085 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18087 salt
->salt_len
= 4 + user_len
;
18089 return (PARSER_OK
);
18092 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18094 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18096 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18098 u32
*digest
= (u32
*) hash_buf
->digest
;
18100 salt_t
*salt
= hash_buf
->salt
;
18102 char *salt_pos
= input_buf
+ 9;
18104 char *hash_pos
= strchr (salt_pos
, '*');
18106 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18110 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18112 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18114 uint salt_len
= hash_pos
- salt_pos
- 1;
18116 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18122 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18123 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18124 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18125 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18126 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18136 salt
->salt_len
= salt_len
;
18138 return (PARSER_OK
);
18141 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18143 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18145 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18147 u32
*digest
= (u32
*) hash_buf
->digest
;
18149 salt_t
*salt
= hash_buf
->salt
;
18151 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18157 char *cry_master_len_pos
= input_buf
+ 9;
18159 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18161 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18163 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18165 cry_master_buf_pos
++;
18167 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18169 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18171 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18173 cry_salt_len_pos
++;
18175 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18177 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18179 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18181 cry_salt_buf_pos
++;
18183 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18185 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18187 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18191 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18193 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18199 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18201 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18203 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18207 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18209 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18211 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18213 public_key_len_pos
++;
18215 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18217 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18219 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18221 public_key_buf_pos
++;
18223 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;
18225 const uint cry_master_len
= atoi (cry_master_len_pos
);
18226 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18227 const uint ckey_len
= atoi (ckey_len_pos
);
18228 const uint public_key_len
= atoi (public_key_len_pos
);
18230 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18231 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18232 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18233 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18235 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18237 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18239 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18242 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18244 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18246 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18249 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18251 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18253 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18256 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18257 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18258 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18261 * store digest (should be unique enought, hopefully)
18264 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18265 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18266 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18267 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18273 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18275 const uint cry_rounds
= atoi (cry_rounds_pos
);
18277 salt
->salt_iter
= cry_rounds
- 1;
18279 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18281 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18283 salt
->salt_len
= salt_len
;
18285 return (PARSER_OK
);
18288 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18290 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18292 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18294 u32
*digest
= (u32
*) hash_buf
->digest
;
18296 salt_t
*salt
= hash_buf
->salt
;
18298 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18300 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18302 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18304 memcpy (temp_input_buf
, input_buf
, input_len
);
18308 char *URI_server_pos
= temp_input_buf
+ 6;
18310 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18312 if (URI_client_pos
== NULL
)
18314 myfree (temp_input_buf
);
18316 return (PARSER_SEPARATOR_UNMATCHED
);
18319 URI_client_pos
[0] = 0;
18322 uint URI_server_len
= strlen (URI_server_pos
);
18324 if (URI_server_len
> 512)
18326 myfree (temp_input_buf
);
18328 return (PARSER_SALT_LENGTH
);
18333 char *user_pos
= strchr (URI_client_pos
, '*');
18335 if (user_pos
== NULL
)
18337 myfree (temp_input_buf
);
18339 return (PARSER_SEPARATOR_UNMATCHED
);
18345 uint URI_client_len
= strlen (URI_client_pos
);
18347 if (URI_client_len
> 512)
18349 myfree (temp_input_buf
);
18351 return (PARSER_SALT_LENGTH
);
18356 char *realm_pos
= strchr (user_pos
, '*');
18358 if (realm_pos
== NULL
)
18360 myfree (temp_input_buf
);
18362 return (PARSER_SEPARATOR_UNMATCHED
);
18368 uint user_len
= strlen (user_pos
);
18370 if (user_len
> 116)
18372 myfree (temp_input_buf
);
18374 return (PARSER_SALT_LENGTH
);
18379 char *method_pos
= strchr (realm_pos
, '*');
18381 if (method_pos
== NULL
)
18383 myfree (temp_input_buf
);
18385 return (PARSER_SEPARATOR_UNMATCHED
);
18391 uint realm_len
= strlen (realm_pos
);
18393 if (realm_len
> 116)
18395 myfree (temp_input_buf
);
18397 return (PARSER_SALT_LENGTH
);
18402 char *URI_prefix_pos
= strchr (method_pos
, '*');
18404 if (URI_prefix_pos
== NULL
)
18406 myfree (temp_input_buf
);
18408 return (PARSER_SEPARATOR_UNMATCHED
);
18411 URI_prefix_pos
[0] = 0;
18414 uint method_len
= strlen (method_pos
);
18416 if (method_len
> 246)
18418 myfree (temp_input_buf
);
18420 return (PARSER_SALT_LENGTH
);
18425 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18427 if (URI_resource_pos
== NULL
)
18429 myfree (temp_input_buf
);
18431 return (PARSER_SEPARATOR_UNMATCHED
);
18434 URI_resource_pos
[0] = 0;
18435 URI_resource_pos
++;
18437 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18439 if (URI_prefix_len
> 245)
18441 myfree (temp_input_buf
);
18443 return (PARSER_SALT_LENGTH
);
18448 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18450 if (URI_suffix_pos
== NULL
)
18452 myfree (temp_input_buf
);
18454 return (PARSER_SEPARATOR_UNMATCHED
);
18457 URI_suffix_pos
[0] = 0;
18460 uint URI_resource_len
= strlen (URI_resource_pos
);
18462 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18464 myfree (temp_input_buf
);
18466 return (PARSER_SALT_LENGTH
);
18471 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18473 if (nonce_pos
== NULL
)
18475 myfree (temp_input_buf
);
18477 return (PARSER_SEPARATOR_UNMATCHED
);
18483 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18485 if (URI_suffix_len
> 245)
18487 myfree (temp_input_buf
);
18489 return (PARSER_SALT_LENGTH
);
18494 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18496 if (nonce_client_pos
== NULL
)
18498 myfree (temp_input_buf
);
18500 return (PARSER_SEPARATOR_UNMATCHED
);
18503 nonce_client_pos
[0] = 0;
18504 nonce_client_pos
++;
18506 uint nonce_len
= strlen (nonce_pos
);
18508 if (nonce_len
< 1 || nonce_len
> 50)
18510 myfree (temp_input_buf
);
18512 return (PARSER_SALT_LENGTH
);
18517 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18519 if (nonce_count_pos
== NULL
)
18521 myfree (temp_input_buf
);
18523 return (PARSER_SEPARATOR_UNMATCHED
);
18526 nonce_count_pos
[0] = 0;
18529 uint nonce_client_len
= strlen (nonce_client_pos
);
18531 if (nonce_client_len
> 50)
18533 myfree (temp_input_buf
);
18535 return (PARSER_SALT_LENGTH
);
18540 char *qop_pos
= strchr (nonce_count_pos
, '*');
18542 if (qop_pos
== NULL
)
18544 myfree (temp_input_buf
);
18546 return (PARSER_SEPARATOR_UNMATCHED
);
18552 uint nonce_count_len
= strlen (nonce_count_pos
);
18554 if (nonce_count_len
> 50)
18556 myfree (temp_input_buf
);
18558 return (PARSER_SALT_LENGTH
);
18563 char *directive_pos
= strchr (qop_pos
, '*');
18565 if (directive_pos
== NULL
)
18567 myfree (temp_input_buf
);
18569 return (PARSER_SEPARATOR_UNMATCHED
);
18572 directive_pos
[0] = 0;
18575 uint qop_len
= strlen (qop_pos
);
18579 myfree (temp_input_buf
);
18581 return (PARSER_SALT_LENGTH
);
18586 char *digest_pos
= strchr (directive_pos
, '*');
18588 if (digest_pos
== NULL
)
18590 myfree (temp_input_buf
);
18592 return (PARSER_SEPARATOR_UNMATCHED
);
18598 uint directive_len
= strlen (directive_pos
);
18600 if (directive_len
!= 3)
18602 myfree (temp_input_buf
);
18604 return (PARSER_SALT_LENGTH
);
18607 if (memcmp (directive_pos
, "MD5", 3))
18609 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18611 myfree (temp_input_buf
);
18613 return (PARSER_SIP_AUTH_DIRECTIVE
);
18617 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18622 uint md5_max_len
= 4 * 64;
18624 uint md5_remaining_len
= md5_max_len
;
18626 uint tmp_md5_buf
[64] = { 0 };
18628 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18630 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18632 md5_len
+= method_len
+ 1;
18633 tmp_md5_ptr
+= method_len
+ 1;
18635 if (URI_prefix_len
> 0)
18637 md5_remaining_len
= md5_max_len
- md5_len
;
18639 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18641 md5_len
+= URI_prefix_len
+ 1;
18642 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18645 md5_remaining_len
= md5_max_len
- md5_len
;
18647 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18649 md5_len
+= URI_resource_len
;
18650 tmp_md5_ptr
+= URI_resource_len
;
18652 if (URI_suffix_len
> 0)
18654 md5_remaining_len
= md5_max_len
- md5_len
;
18656 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18658 md5_len
+= 1 + URI_suffix_len
;
18661 uint tmp_digest
[4] = { 0 };
18663 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18665 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18666 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18667 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18668 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18674 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18676 uint esalt_len
= 0;
18678 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18680 // there are 2 possibilities for the esalt:
18682 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18684 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18686 if (esalt_len
> max_esalt_len
)
18688 myfree (temp_input_buf
);
18690 return (PARSER_SALT_LENGTH
);
18693 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18705 esalt_len
= 1 + nonce_len
+ 1 + 32;
18707 if (esalt_len
> max_esalt_len
)
18709 myfree (temp_input_buf
);
18711 return (PARSER_SALT_LENGTH
);
18714 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18722 // add 0x80 to esalt
18724 esalt_buf_ptr
[esalt_len
] = 0x80;
18726 sip
->esalt_len
= esalt_len
;
18732 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18734 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18736 uint max_salt_len
= 119;
18738 if (salt_len
> max_salt_len
)
18740 myfree (temp_input_buf
);
18742 return (PARSER_SALT_LENGTH
);
18745 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18747 sip
->salt_len
= salt_len
;
18750 * fake salt (for sorting)
18753 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18757 uint fake_salt_len
= salt_len
;
18759 if (fake_salt_len
> max_salt_len
)
18761 fake_salt_len
= max_salt_len
;
18764 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18766 salt
->salt_len
= fake_salt_len
;
18772 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18773 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18774 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18775 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18777 digest
[0] = byte_swap_32 (digest
[0]);
18778 digest
[1] = byte_swap_32 (digest
[1]);
18779 digest
[2] = byte_swap_32 (digest
[2]);
18780 digest
[3] = byte_swap_32 (digest
[3]);
18782 myfree (temp_input_buf
);
18784 return (PARSER_OK
);
18787 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18789 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18791 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18793 u32
*digest
= (u32
*) hash_buf
->digest
;
18795 salt_t
*salt
= hash_buf
->salt
;
18799 char *digest_pos
= input_buf
;
18801 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18808 char *salt_buf
= input_buf
+ 8 + 1;
18812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18814 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18816 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18818 salt
->salt_len
= salt_len
;
18820 return (PARSER_OK
);
18823 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18825 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18827 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18829 u32
*digest
= (u32
*) hash_buf
->digest
;
18831 salt_t
*salt
= hash_buf
->salt
;
18833 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18839 char *p_buf_pos
= input_buf
+ 4;
18841 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18843 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18845 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18847 NumCyclesPower_pos
++;
18849 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18851 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18853 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18857 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18859 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18861 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18865 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18867 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18869 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18873 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18875 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18877 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18881 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18883 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18885 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18889 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18891 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18893 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18897 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18899 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18901 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18905 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18907 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18909 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18913 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;
18915 const uint iter
= atoi (NumCyclesPower_pos
);
18916 const uint crc
= atoi (crc_buf_pos
);
18917 const uint p_buf
= atoi (p_buf_pos
);
18918 const uint salt_len
= atoi (salt_len_pos
);
18919 const uint iv_len
= atoi (iv_len_pos
);
18920 const uint unpack_size
= atoi (unpack_size_pos
);
18921 const uint data_len
= atoi (data_len_pos
);
18927 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18928 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18930 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18932 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18934 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18940 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18941 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18942 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18943 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18945 seven_zip
->iv_len
= iv_len
;
18947 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18949 seven_zip
->salt_len
= 0;
18951 seven_zip
->crc
= crc
;
18953 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18955 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18957 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18960 seven_zip
->data_len
= data_len
;
18962 seven_zip
->unpack_size
= unpack_size
;
18966 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18967 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18968 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18969 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18971 salt
->salt_len
= 16;
18973 salt
->salt_sign
[0] = iter
;
18975 salt
->salt_iter
= 1 << iter
;
18986 return (PARSER_OK
);
18989 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18991 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18993 u32
*digest
= (u32
*) hash_buf
->digest
;
18995 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18996 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18997 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18998 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18999 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19000 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19001 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19002 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19004 digest
[0] = byte_swap_32 (digest
[0]);
19005 digest
[1] = byte_swap_32 (digest
[1]);
19006 digest
[2] = byte_swap_32 (digest
[2]);
19007 digest
[3] = byte_swap_32 (digest
[3]);
19008 digest
[4] = byte_swap_32 (digest
[4]);
19009 digest
[5] = byte_swap_32 (digest
[5]);
19010 digest
[6] = byte_swap_32 (digest
[6]);
19011 digest
[7] = byte_swap_32 (digest
[7]);
19013 return (PARSER_OK
);
19016 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19018 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19020 u32
*digest
= (u32
*) hash_buf
->digest
;
19022 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19023 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19024 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19025 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19026 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19027 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19028 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19029 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19030 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19031 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19032 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19033 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19034 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19035 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19036 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19037 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19039 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19040 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19041 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19042 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19043 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19044 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19045 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19046 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19047 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19048 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19049 digest
[10] = byte_swap_32 (digest
[10]);
19050 digest
[11] = byte_swap_32 (digest
[11]);
19051 digest
[12] = byte_swap_32 (digest
[12]);
19052 digest
[13] = byte_swap_32 (digest
[13]);
19053 digest
[14] = byte_swap_32 (digest
[14]);
19054 digest
[15] = byte_swap_32 (digest
[15]);
19056 return (PARSER_OK
);
19059 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19061 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19063 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19065 u32
*digest
= (u32
*) hash_buf
->digest
;
19067 salt_t
*salt
= hash_buf
->salt
;
19069 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19077 char *iter_pos
= input_buf
+ 4;
19079 u32 iter
= atoi (iter_pos
);
19081 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19082 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19084 // first is *raw* salt
19086 char *salt_pos
= strchr (iter_pos
, ':');
19088 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19092 char *hash_pos
= strchr (salt_pos
, ':');
19094 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19096 u32 salt_len
= hash_pos
- salt_pos
;
19098 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19102 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19104 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19108 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19114 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19115 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19117 salt
->salt_len
= salt_len
;
19118 salt
->salt_iter
= iter
- 1;
19122 u8 tmp_buf
[100] = { 0 };
19124 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19126 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19128 memcpy (digest
, tmp_buf
, 16);
19130 // add some stuff to normal salt to make sorted happy
19132 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19133 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19134 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19135 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19136 salt
->salt_buf
[4] = salt
->salt_iter
;
19138 return (PARSER_OK
);
19141 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19143 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19145 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19147 u32
*digest
= (u32
*) hash_buf
->digest
;
19149 salt_t
*salt
= hash_buf
->salt
;
19151 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19159 char *iter_pos
= input_buf
+ 5;
19161 u32 iter
= atoi (iter_pos
);
19163 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19164 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19166 // first is *raw* salt
19168 char *salt_pos
= strchr (iter_pos
, ':');
19170 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19174 char *hash_pos
= strchr (salt_pos
, ':');
19176 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19178 u32 salt_len
= hash_pos
- salt_pos
;
19180 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19184 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19186 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19190 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19196 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19197 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19199 salt
->salt_len
= salt_len
;
19200 salt
->salt_iter
= iter
- 1;
19204 u8 tmp_buf
[100] = { 0 };
19206 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19208 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19210 memcpy (digest
, tmp_buf
, 16);
19212 digest
[0] = byte_swap_32 (digest
[0]);
19213 digest
[1] = byte_swap_32 (digest
[1]);
19214 digest
[2] = byte_swap_32 (digest
[2]);
19215 digest
[3] = byte_swap_32 (digest
[3]);
19217 // add some stuff to normal salt to make sorted happy
19219 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19220 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19221 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19222 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19223 salt
->salt_buf
[4] = salt
->salt_iter
;
19225 return (PARSER_OK
);
19228 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19230 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19232 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19234 u64
*digest
= (u64
*) hash_buf
->digest
;
19236 salt_t
*salt
= hash_buf
->salt
;
19238 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19246 char *iter_pos
= input_buf
+ 7;
19248 u32 iter
= atoi (iter_pos
);
19250 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19251 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19253 // first is *raw* salt
19255 char *salt_pos
= strchr (iter_pos
, ':');
19257 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19261 char *hash_pos
= strchr (salt_pos
, ':');
19263 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19265 u32 salt_len
= hash_pos
- salt_pos
;
19267 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19271 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19273 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19277 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19283 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19284 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19286 salt
->salt_len
= salt_len
;
19287 salt
->salt_iter
= iter
- 1;
19291 u8 tmp_buf
[100] = { 0 };
19293 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19295 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19297 memcpy (digest
, tmp_buf
, 64);
19299 digest
[0] = byte_swap_64 (digest
[0]);
19300 digest
[1] = byte_swap_64 (digest
[1]);
19301 digest
[2] = byte_swap_64 (digest
[2]);
19302 digest
[3] = byte_swap_64 (digest
[3]);
19303 digest
[4] = byte_swap_64 (digest
[4]);
19304 digest
[5] = byte_swap_64 (digest
[5]);
19305 digest
[6] = byte_swap_64 (digest
[6]);
19306 digest
[7] = byte_swap_64 (digest
[7]);
19308 // add some stuff to normal salt to make sorted happy
19310 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19311 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19312 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19313 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19314 salt
->salt_buf
[4] = salt
->salt_iter
;
19316 return (PARSER_OK
);
19319 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19321 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19323 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19325 uint
*digest
= (uint
*) hash_buf
->digest
;
19327 salt_t
*salt
= hash_buf
->salt
;
19333 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19335 char *hash_pos
= strchr (salt_pos
, '$');
19337 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19339 u32 salt_len
= hash_pos
- salt_pos
;
19341 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19345 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19347 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19351 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19352 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19370 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19371 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19373 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19374 salt
->salt_len
= 8;
19376 return (PARSER_OK
);
19379 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19381 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19383 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19385 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19387 if (c19
& 3) return (PARSER_HASH_VALUE
);
19389 salt_t
*salt
= hash_buf
->salt
;
19391 u32
*digest
= (u32
*) hash_buf
->digest
;
19395 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19396 | itoa64_to_int (input_buf
[2]) << 6
19397 | itoa64_to_int (input_buf
[3]) << 12
19398 | itoa64_to_int (input_buf
[4]) << 18;
19402 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19403 | itoa64_to_int (input_buf
[6]) << 6
19404 | itoa64_to_int (input_buf
[7]) << 12
19405 | itoa64_to_int (input_buf
[8]) << 18;
19407 salt
->salt_len
= 4;
19409 u8 tmp_buf
[100] = { 0 };
19411 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19413 memcpy (digest
, tmp_buf
, 8);
19417 IP (digest
[0], digest
[1], tt
);
19419 digest
[0] = rotr32 (digest
[0], 31);
19420 digest
[1] = rotr32 (digest
[1], 31);
19424 return (PARSER_OK
);
19427 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19429 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19431 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19433 u32
*digest
= (u32
*) hash_buf
->digest
;
19435 salt_t
*salt
= hash_buf
->salt
;
19441 char *type_pos
= input_buf
+ 6 + 1;
19443 char *salt_pos
= strchr (type_pos
, '*');
19445 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19447 u32 type_len
= salt_pos
- type_pos
;
19449 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19453 char *crypted_pos
= strchr (salt_pos
, '*');
19455 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19457 u32 salt_len
= crypted_pos
- salt_pos
;
19459 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19463 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19465 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19471 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19472 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19474 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19475 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19477 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19478 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19479 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19480 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19482 salt
->salt_len
= 24;
19483 salt
->salt_iter
= ROUNDS_RAR3
;
19485 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19486 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19488 digest
[0] = 0xc43d7b00;
19489 digest
[1] = 0x40070000;
19493 return (PARSER_OK
);
19496 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19498 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19500 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19502 u32
*digest
= (u32
*) hash_buf
->digest
;
19504 salt_t
*salt
= hash_buf
->salt
;
19506 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19512 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19514 char *param1_pos
= strchr (param0_pos
, '$');
19516 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19518 u32 param0_len
= param1_pos
- param0_pos
;
19522 char *param2_pos
= strchr (param1_pos
, '$');
19524 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19526 u32 param1_len
= param2_pos
- param1_pos
;
19530 char *param3_pos
= strchr (param2_pos
, '$');
19532 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19534 u32 param2_len
= param3_pos
- param2_pos
;
19538 char *param4_pos
= strchr (param3_pos
, '$');
19540 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19542 u32 param3_len
= param4_pos
- param3_pos
;
19546 char *param5_pos
= strchr (param4_pos
, '$');
19548 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19550 u32 param4_len
= param5_pos
- param4_pos
;
19554 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19556 char *salt_buf
= param1_pos
;
19557 char *iv
= param3_pos
;
19558 char *pswcheck
= param5_pos
;
19560 const uint salt_len
= atoi (param0_pos
);
19561 const uint iterations
= atoi (param2_pos
);
19562 const uint pswcheck_len
= atoi (param4_pos
);
19568 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19569 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19570 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19572 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19573 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19574 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19580 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19581 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19582 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19583 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19585 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19586 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19587 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19588 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19590 salt
->salt_len
= 16;
19592 salt
->salt_sign
[0] = iterations
;
19594 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19600 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19601 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19605 return (PARSER_OK
);
19608 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19610 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19612 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19614 u32
*digest
= (u32
*) hash_buf
->digest
;
19616 salt_t
*salt
= hash_buf
->salt
;
19618 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19625 char *account_pos
= input_buf
+ 11 + 1;
19631 if (account_pos
[0] == '*')
19635 data_pos
= strchr (account_pos
, '*');
19640 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19642 uint account_len
= data_pos
- account_pos
+ 1;
19644 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19649 data_len
= input_len
- 11 - 1 - account_len
- 2;
19651 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19655 /* assume $krb5tgs$23$checksum$edata2 */
19656 data_pos
= account_pos
;
19658 memcpy (krb5tgs
->account_info
, "**", 3);
19660 data_len
= input_len
- 11 - 1 - 1;
19663 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19665 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19667 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19669 const char p0
= data_pos
[i
+ 0];
19670 const char p1
= data_pos
[i
+ 1];
19672 *checksum_ptr
++ = hex_convert (p1
) << 0
19673 | hex_convert (p0
) << 4;
19676 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19678 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19681 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19683 const char p0
= data_pos
[i
+ 0];
19684 const char p1
= data_pos
[i
+ 1];
19685 *edata_ptr
++ = hex_convert (p1
) << 0
19686 | hex_convert (p0
) << 4;
19689 /* this is needed for hmac_md5 */
19690 *edata_ptr
++ = 0x80;
19692 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19693 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19694 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19695 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19697 salt
->salt_len
= 32;
19699 digest
[0] = krb5tgs
->checksum
[0];
19700 digest
[1] = krb5tgs
->checksum
[1];
19701 digest
[2] = krb5tgs
->checksum
[2];
19702 digest
[3] = krb5tgs
->checksum
[3];
19704 return (PARSER_OK
);
19707 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19709 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19711 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19713 u32
*digest
= (u32
*) hash_buf
->digest
;
19715 salt_t
*salt
= hash_buf
->salt
;
19722 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19726 char *wrapped_key_pos
;
19730 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19732 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19734 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19736 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19741 data_pos
= salt_pos
;
19743 wrapped_key_pos
= strchr (salt_pos
, '*');
19745 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19747 uint salt_len
= wrapped_key_pos
- salt_pos
;
19749 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19754 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19756 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19758 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19759 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19760 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19761 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19765 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19766 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19767 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19768 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19769 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19770 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19772 salt
->salt_len
= 40;
19774 digest
[0] = salt
->salt_buf
[0];
19775 digest
[1] = salt
->salt_buf
[1];
19776 digest
[2] = salt
->salt_buf
[2];
19777 digest
[3] = salt
->salt_buf
[3];
19779 return (PARSER_OK
);
19782 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19784 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19786 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19788 u32
*digest
= (u32
*) hash_buf
->digest
;
19790 salt_t
*salt
= hash_buf
->salt
;
19792 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19802 char *algorithm_pos
;
19804 char *final_random_seed_pos
;
19805 u32 final_random_seed_len
;
19807 char *transf_random_seed_pos
;
19808 u32 transf_random_seed_len
;
19813 /* default is no keyfile provided */
19814 char *keyfile_len_pos
;
19815 u32 keyfile_len
= 0;
19816 u32 is_keyfile_present
= 0;
19817 char *keyfile_inline_pos
;
19820 /* specific to version 1 */
19821 char *contents_len_pos
;
19823 char *contents_pos
;
19825 /* specific to version 2 */
19826 char *expected_bytes_pos
;
19827 u32 expected_bytes_len
;
19829 char *contents_hash_pos
;
19830 u32 contents_hash_len
;
19832 version_pos
= input_buf
+ 8 + 1 + 1;
19834 keepass
->version
= atoi (version_pos
);
19836 rounds_pos
= strchr (version_pos
, '*');
19838 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19842 salt
->salt_iter
= (atoi (rounds_pos
));
19844 algorithm_pos
= strchr (rounds_pos
, '*');
19846 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19850 keepass
->algorithm
= atoi (algorithm_pos
);
19852 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19854 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19856 final_random_seed_pos
++;
19858 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19859 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19860 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19861 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19863 if (keepass
->version
== 2)
19865 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19866 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19867 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19868 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19871 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19873 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19875 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19877 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19878 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19880 transf_random_seed_pos
++;
19882 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19883 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19884 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19885 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19886 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19887 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19888 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19889 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19891 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19893 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19895 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19897 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19901 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19902 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19903 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19904 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19906 if (keepass
->version
== 1)
19908 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19910 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19912 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19914 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19916 contents_hash_pos
++;
19918 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19919 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19920 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19921 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19922 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19923 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19924 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19925 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19927 /* get length of contents following */
19928 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19930 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19932 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19934 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19938 u32 inline_flag
= atoi (inline_flag_pos
);
19940 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19942 contents_len_pos
= strchr (inline_flag_pos
, '*');
19944 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19946 contents_len_pos
++;
19948 contents_len
= atoi (contents_len_pos
);
19950 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19952 contents_pos
= strchr (contents_len_pos
, '*');
19954 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19960 keepass
->contents_len
= contents_len
;
19962 contents_len
= contents_len
/ 4;
19964 keyfile_inline_pos
= strchr (contents_pos
, '*');
19966 u32 real_contents_len
;
19968 if (keyfile_inline_pos
== NULL
)
19969 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19972 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19973 keyfile_inline_pos
++;
19974 is_keyfile_present
= 1;
19977 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19979 for (i
= 0; i
< contents_len
; i
++)
19980 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19982 else if (keepass
->version
== 2)
19984 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19986 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19988 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19990 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19992 expected_bytes_pos
++;
19994 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19995 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19996 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19997 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19998 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19999 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20000 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20001 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20003 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20005 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20007 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20009 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20011 contents_hash_pos
++;
20013 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20014 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20015 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20016 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20017 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20018 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20019 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20020 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20022 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20024 if (keyfile_inline_pos
== NULL
)
20025 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20028 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20029 keyfile_inline_pos
++;
20030 is_keyfile_present
= 1;
20032 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20035 if (is_keyfile_present
!= 0)
20037 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20041 keyfile_len
= atoi (keyfile_len_pos
);
20043 keepass
->keyfile_len
= keyfile_len
;
20045 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20047 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20049 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20053 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20055 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20057 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20058 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20059 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20060 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20061 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20062 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20063 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20064 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20067 digest
[0] = keepass
->enc_iv
[0];
20068 digest
[1] = keepass
->enc_iv
[1];
20069 digest
[2] = keepass
->enc_iv
[2];
20070 digest
[3] = keepass
->enc_iv
[3];
20072 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20073 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20074 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20075 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20076 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20077 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20078 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20079 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20081 return (PARSER_OK
);
20084 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20086 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20088 u32
*digest
= (u32
*) hash_buf
->digest
;
20090 salt_t
*salt
= hash_buf
->salt
;
20092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20096 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20097 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20098 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20099 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20101 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20103 uint salt_len
= input_len
- 64 - 1;
20105 char *salt_buf
= input_buf
+ 64 + 1;
20107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20113 salt
->salt_len
= salt_len
;
20116 * we can precompute the first sha256 transform
20119 uint w
[16] = { 0 };
20121 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20122 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20123 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20124 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20125 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20126 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20127 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20128 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20129 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20130 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20131 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20132 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20133 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20134 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20135 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20136 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20138 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20140 sha256_64 (w
, pc256
);
20142 salt
->salt_buf_pc
[0] = pc256
[0];
20143 salt
->salt_buf_pc
[1] = pc256
[1];
20144 salt
->salt_buf_pc
[2] = pc256
[2];
20145 salt
->salt_buf_pc
[3] = pc256
[3];
20146 salt
->salt_buf_pc
[4] = pc256
[4];
20147 salt
->salt_buf_pc
[5] = pc256
[5];
20148 salt
->salt_buf_pc
[6] = pc256
[6];
20149 salt
->salt_buf_pc
[7] = pc256
[7];
20151 digest
[0] -= pc256
[0];
20152 digest
[1] -= pc256
[1];
20153 digest
[2] -= pc256
[2];
20154 digest
[3] -= pc256
[3];
20155 digest
[4] -= pc256
[4];
20156 digest
[5] -= pc256
[5];
20157 digest
[6] -= pc256
[6];
20158 digest
[7] -= pc256
[7];
20160 return (PARSER_OK
);
20163 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20165 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20167 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20169 u32
*digest
= (u32
*) hash_buf
->digest
;
20171 salt_t
*salt
= hash_buf
->salt
;
20177 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20179 char *data_buf_pos
= strchr (data_len_pos
, '$');
20181 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20183 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20185 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20186 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20190 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20192 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20194 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20196 u32 data_len
= atoi (data_len_pos
);
20198 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20204 char *salt_pos
= data_buf_pos
;
20206 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20207 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20208 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20209 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20211 // this is actually the CT, which is also the hash later (if matched)
20213 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20214 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20215 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20216 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20218 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20220 salt
->salt_iter
= 10 - 1;
20226 digest
[0] = salt
->salt_buf
[4];
20227 digest
[1] = salt
->salt_buf
[5];
20228 digest
[2] = salt
->salt_buf
[6];
20229 digest
[3] = salt
->salt_buf
[7];
20231 return (PARSER_OK
);
20234 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20236 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20238 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20240 u32
*digest
= (u32
*) hash_buf
->digest
;
20242 salt_t
*salt
= hash_buf
->salt
;
20248 char *salt_pos
= input_buf
+ 11 + 1;
20250 char *iter_pos
= strchr (salt_pos
, ',');
20252 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20254 u32 salt_len
= iter_pos
- salt_pos
;
20256 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20260 char *hash_pos
= strchr (iter_pos
, ',');
20262 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20264 u32 iter_len
= hash_pos
- iter_pos
;
20266 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20270 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20272 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20278 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20279 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20280 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20281 salt
->salt_buf
[3] = 0x00018000;
20283 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20284 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20285 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20286 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20288 salt
->salt_len
= salt_len
/ 2;
20290 salt
->salt_iter
= atoi (iter_pos
) - 1;
20296 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20297 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20298 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20299 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20300 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20301 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20302 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20303 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20305 return (PARSER_OK
);
20308 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20310 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20312 u32
*digest
= (u32
*) hash_buf
->digest
;
20314 salt_t
*salt
= hash_buf
->salt
;
20320 char *hash_pos
= input_buf
+ 64;
20321 char *salt1_pos
= input_buf
+ 128;
20322 char *salt2_pos
= input_buf
;
20328 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20329 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20330 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20331 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20333 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20334 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20335 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20336 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20338 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20339 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20340 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20341 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20343 salt
->salt_len
= 48;
20345 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20351 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20352 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20353 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20354 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20355 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20356 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20357 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20358 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20360 return (PARSER_OK
);
20363 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20365 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20367 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20368 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20370 u32
*digest
= (u32
*) hash_buf
->digest
;
20372 salt_t
*salt
= hash_buf
->salt
;
20374 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20380 char *param0_pos
= input_buf
+ 6 + 1;
20382 char *param1_pos
= strchr (param0_pos
, '*');
20384 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20386 u32 param0_len
= param1_pos
- param0_pos
;
20390 char *param2_pos
= strchr (param1_pos
, '*');
20392 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20394 u32 param1_len
= param2_pos
- param1_pos
;
20398 char *param3_pos
= strchr (param2_pos
, '*');
20400 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20402 u32 param2_len
= param3_pos
- param2_pos
;
20406 char *param4_pos
= strchr (param3_pos
, '*');
20408 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20410 u32 param3_len
= param4_pos
- param3_pos
;
20414 char *param5_pos
= strchr (param4_pos
, '*');
20416 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20418 u32 param4_len
= param5_pos
- param4_pos
;
20422 char *param6_pos
= strchr (param5_pos
, '*');
20424 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20426 u32 param5_len
= param6_pos
- param5_pos
;
20430 char *param7_pos
= strchr (param6_pos
, '*');
20432 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20434 u32 param6_len
= param7_pos
- param6_pos
;
20438 char *param8_pos
= strchr (param7_pos
, '*');
20440 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20442 u32 param7_len
= param8_pos
- param7_pos
;
20446 const uint type
= atoi (param0_pos
);
20447 const uint mode
= atoi (param1_pos
);
20448 const uint magic
= atoi (param2_pos
);
20450 char *salt_buf
= param3_pos
;
20452 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20454 const uint compress_length
= atoi (param5_pos
);
20456 char *data_buf
= param6_pos
;
20457 char *auth
= param7_pos
;
20463 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20465 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20467 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20469 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20471 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20473 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20475 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20477 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20479 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20481 if (type
!= 0) return (PARSER_SALT_VALUE
);
20483 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20485 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20487 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20495 zip2
->magic
= magic
;
20499 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20500 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20501 zip2
->salt_buf
[2] = 0;
20502 zip2
->salt_buf
[3] = 0;
20504 zip2
->salt_len
= 8;
20506 else if (mode
== 2)
20508 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20509 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20510 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20511 zip2
->salt_buf
[3] = 0;
20513 zip2
->salt_len
= 12;
20515 else if (mode
== 3)
20517 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20518 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20519 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20520 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20522 zip2
->salt_len
= 16;
20525 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20526 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20527 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20528 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20530 zip2
->verify_bytes
= verify_bytes
;
20532 zip2
->compress_length
= compress_length
;
20534 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20536 for (uint i
= 0; i
< param6_len
; i
+= 2)
20538 const char p0
= data_buf
[i
+ 0];
20539 const char p1
= data_buf
[i
+ 1];
20541 *data_buf_ptr
++ = hex_convert (p1
) << 0
20542 | hex_convert (p0
) << 4;
20547 *data_buf_ptr
= 0x80;
20549 char *auth_ptr
= (char *) zip2
->auth_buf
;
20551 for (uint i
= 0; i
< param7_len
; i
+= 2)
20553 const char p0
= auth
[i
+ 0];
20554 const char p1
= auth
[i
+ 1];
20556 *auth_ptr
++ = hex_convert (p1
) << 0
20557 | hex_convert (p0
) << 4;
20566 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20567 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20568 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20569 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20570 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20571 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20572 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20573 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20575 salt
->salt_len
= 32;
20577 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20580 * digest buf (fake)
20583 digest
[0] = zip2
->auth_buf
[0];
20584 digest
[1] = zip2
->auth_buf
[1];
20585 digest
[2] = zip2
->auth_buf
[2];
20586 digest
[3] = zip2
->auth_buf
[3];
20588 return (PARSER_OK
);
20591 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20593 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20595 u32
*digest
= (u32
*) hash_buf
->digest
;
20597 salt_t
*salt
= hash_buf
->salt
;
20599 win8phone_t
*esalt
= hash_buf
->esalt
;
20601 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20602 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20603 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20604 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20605 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20606 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20607 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20608 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20610 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20612 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20614 u32
*salt_buf
= esalt
->salt_buf
;
20616 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20618 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20621 salt
->salt_buf
[0] = salt_buf
[0];
20622 salt
->salt_buf
[1] = salt_buf
[1];
20623 salt
->salt_buf
[2] = salt_buf
[2];
20624 salt
->salt_buf
[3] = salt_buf
[3];
20625 salt
->salt_buf
[4] = salt_buf
[4];
20626 salt
->salt_buf
[5] = salt_buf
[5];
20627 salt
->salt_buf
[6] = salt_buf
[6];
20628 salt
->salt_buf
[7] = salt_buf
[7];
20630 salt
->salt_len
= 64;
20632 return (PARSER_OK
);
20636 * parallel running threads
20641 BOOL WINAPI
sigHandler_default (DWORD sig
)
20645 case CTRL_CLOSE_EVENT
:
20648 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20649 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20650 * function otherwise it is too late (e.g. after returning from this function)
20655 SetConsoleCtrlHandler (NULL
, TRUE
);
20662 case CTRL_LOGOFF_EVENT
:
20663 case CTRL_SHUTDOWN_EVENT
:
20667 SetConsoleCtrlHandler (NULL
, TRUE
);
20675 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20679 case CTRL_CLOSE_EVENT
:
20683 SetConsoleCtrlHandler (NULL
, TRUE
);
20690 case CTRL_LOGOFF_EVENT
:
20691 case CTRL_SHUTDOWN_EVENT
:
20695 SetConsoleCtrlHandler (NULL
, TRUE
);
20703 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20705 if (callback
== NULL
)
20707 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20711 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20717 void sigHandler_default (int sig
)
20721 signal (sig
, NULL
);
20724 void sigHandler_benchmark (int sig
)
20728 signal (sig
, NULL
);
20731 void hc_signal (void (callback
) (int))
20733 if (callback
== NULL
) callback
= SIG_DFL
;
20735 signal (SIGINT
, callback
);
20736 signal (SIGTERM
, callback
);
20737 signal (SIGABRT
, callback
);
20742 void status_display ();
20744 void *thread_keypress (void *p
)
20746 int benchmark
= *((int *) p
);
20748 uint quiet
= data
.quiet
;
20752 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20754 int ch
= tty_getchar();
20756 if (ch
== -1) break;
20758 if (ch
== 0) continue;
20760 //https://github.com/hashcat/hashcat/issues/302
20765 hc_thread_mutex_lock (mux_display
);
20781 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20782 if (quiet
== 0) fflush (stdout
);
20794 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20795 if (quiet
== 0) fflush (stdout
);
20807 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20808 if (quiet
== 0) fflush (stdout
);
20820 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20821 if (quiet
== 0) fflush (stdout
);
20829 if (benchmark
== 1) break;
20831 stop_at_checkpoint ();
20835 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20836 if (quiet
== 0) fflush (stdout
);
20844 if (benchmark
== 1)
20856 //https://github.com/hashcat/hashcat/issues/302
20861 hc_thread_mutex_unlock (mux_display
);
20873 bool class_num (const u8 c
)
20875 return ((c
>= '0') && (c
<= '9'));
20878 bool class_lower (const u8 c
)
20880 return ((c
>= 'a') && (c
<= 'z'));
20883 bool class_upper (const u8 c
)
20885 return ((c
>= 'A') && (c
<= 'Z'));
20888 bool class_alpha (const u8 c
)
20890 return (class_lower (c
) || class_upper (c
));
20893 int conv_ctoi (const u8 c
)
20899 else if (class_upper (c
))
20901 return c
- 'A' + 10;
20907 int conv_itoc (const u8 c
)
20915 return c
+ 'A' - 10;
20925 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20926 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20927 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20928 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20929 #define MAX_KERNEL_RULES 255
20930 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20931 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20932 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20934 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20935 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20936 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20937 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20939 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20944 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20946 switch (rule_buf
[rule_pos
])
20952 case RULE_OP_MANGLE_NOOP
:
20953 SET_NAME (rule
, rule_buf
[rule_pos
]);
20956 case RULE_OP_MANGLE_LREST
:
20957 SET_NAME (rule
, rule_buf
[rule_pos
]);
20960 case RULE_OP_MANGLE_UREST
:
20961 SET_NAME (rule
, rule_buf
[rule_pos
]);
20964 case RULE_OP_MANGLE_LREST_UFIRST
:
20965 SET_NAME (rule
, rule_buf
[rule_pos
]);
20968 case RULE_OP_MANGLE_UREST_LFIRST
:
20969 SET_NAME (rule
, rule_buf
[rule_pos
]);
20972 case RULE_OP_MANGLE_TREST
:
20973 SET_NAME (rule
, rule_buf
[rule_pos
]);
20976 case RULE_OP_MANGLE_TOGGLE_AT
:
20977 SET_NAME (rule
, rule_buf
[rule_pos
]);
20978 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20981 case RULE_OP_MANGLE_REVERSE
:
20982 SET_NAME (rule
, rule_buf
[rule_pos
]);
20985 case RULE_OP_MANGLE_DUPEWORD
:
20986 SET_NAME (rule
, rule_buf
[rule_pos
]);
20989 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20990 SET_NAME (rule
, rule_buf
[rule_pos
]);
20991 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20994 case RULE_OP_MANGLE_REFLECT
:
20995 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 case RULE_OP_MANGLE_ROTATE_LEFT
:
20999 SET_NAME (rule
, rule_buf
[rule_pos
]);
21002 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21003 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 case RULE_OP_MANGLE_APPEND
:
21007 SET_NAME (rule
, rule_buf
[rule_pos
]);
21008 SET_P0 (rule
, rule_buf
[rule_pos
]);
21011 case RULE_OP_MANGLE_PREPEND
:
21012 SET_NAME (rule
, rule_buf
[rule_pos
]);
21013 SET_P0 (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_DELETE_FIRST
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21020 case RULE_OP_MANGLE_DELETE_LAST
:
21021 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 case RULE_OP_MANGLE_DELETE_AT
:
21025 SET_NAME (rule
, rule_buf
[rule_pos
]);
21026 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21029 case RULE_OP_MANGLE_EXTRACT
:
21030 SET_NAME (rule
, rule_buf
[rule_pos
]);
21031 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21032 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21035 case RULE_OP_MANGLE_OMIT
:
21036 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21038 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_INSERT
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21043 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21044 SET_P1 (rule
, rule_buf
[rule_pos
]);
21047 case RULE_OP_MANGLE_OVERSTRIKE
:
21048 SET_NAME (rule
, rule_buf
[rule_pos
]);
21049 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21050 SET_P1 (rule
, rule_buf
[rule_pos
]);
21053 case RULE_OP_MANGLE_TRUNCATE_AT
:
21054 SET_NAME (rule
, rule_buf
[rule_pos
]);
21055 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_REPLACE
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21060 SET_P0 (rule
, rule_buf
[rule_pos
]);
21061 SET_P1 (rule
, rule_buf
[rule_pos
]);
21064 case RULE_OP_MANGLE_PURGECHAR
:
21068 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21072 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21073 SET_NAME (rule
, rule_buf
[rule_pos
]);
21074 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21077 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21078 SET_NAME (rule
, rule_buf
[rule_pos
]);
21079 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21082 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21083 SET_NAME (rule
, rule_buf
[rule_pos
]);
21086 case RULE_OP_MANGLE_SWITCH_FIRST
:
21087 SET_NAME (rule
, rule_buf
[rule_pos
]);
21090 case RULE_OP_MANGLE_SWITCH_LAST
:
21091 SET_NAME (rule
, rule_buf
[rule_pos
]);
21094 case RULE_OP_MANGLE_SWITCH_AT
:
21095 SET_NAME (rule
, rule_buf
[rule_pos
]);
21096 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21097 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21100 case RULE_OP_MANGLE_CHR_SHIFTL
:
21101 SET_NAME (rule
, rule_buf
[rule_pos
]);
21102 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21105 case RULE_OP_MANGLE_CHR_SHIFTR
:
21106 SET_NAME (rule
, rule_buf
[rule_pos
]);
21107 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21110 case RULE_OP_MANGLE_CHR_INCR
:
21111 SET_NAME (rule
, rule_buf
[rule_pos
]);
21112 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21115 case RULE_OP_MANGLE_CHR_DECR
:
21116 SET_NAME (rule
, rule_buf
[rule_pos
]);
21117 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21120 case RULE_OP_MANGLE_REPLACE_NP1
:
21121 SET_NAME (rule
, rule_buf
[rule_pos
]);
21122 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21125 case RULE_OP_MANGLE_REPLACE_NM1
:
21126 SET_NAME (rule
, rule_buf
[rule_pos
]);
21127 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21130 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21131 SET_NAME (rule
, rule_buf
[rule_pos
]);
21132 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21135 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21136 SET_NAME (rule
, rule_buf
[rule_pos
]);
21137 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21140 case RULE_OP_MANGLE_TITLE
:
21141 SET_NAME (rule
, rule_buf
[rule_pos
]);
21150 if (rule_pos
< rule_len
) return (-1);
21155 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21159 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21163 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21167 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21171 case RULE_OP_MANGLE_NOOP
:
21172 rule_buf
[rule_pos
] = rule_cmd
;
21175 case RULE_OP_MANGLE_LREST
:
21176 rule_buf
[rule_pos
] = rule_cmd
;
21179 case RULE_OP_MANGLE_UREST
:
21180 rule_buf
[rule_pos
] = rule_cmd
;
21183 case RULE_OP_MANGLE_LREST_UFIRST
:
21184 rule_buf
[rule_pos
] = rule_cmd
;
21187 case RULE_OP_MANGLE_UREST_LFIRST
:
21188 rule_buf
[rule_pos
] = rule_cmd
;
21191 case RULE_OP_MANGLE_TREST
:
21192 rule_buf
[rule_pos
] = rule_cmd
;
21195 case RULE_OP_MANGLE_TOGGLE_AT
:
21196 rule_buf
[rule_pos
] = rule_cmd
;
21197 GET_P0_CONV (rule
);
21200 case RULE_OP_MANGLE_REVERSE
:
21201 rule_buf
[rule_pos
] = rule_cmd
;
21204 case RULE_OP_MANGLE_DUPEWORD
:
21205 rule_buf
[rule_pos
] = rule_cmd
;
21208 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21209 rule_buf
[rule_pos
] = rule_cmd
;
21210 GET_P0_CONV (rule
);
21213 case RULE_OP_MANGLE_REFLECT
:
21214 rule_buf
[rule_pos
] = rule_cmd
;
21217 case RULE_OP_MANGLE_ROTATE_LEFT
:
21218 rule_buf
[rule_pos
] = rule_cmd
;
21221 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21222 rule_buf
[rule_pos
] = rule_cmd
;
21225 case RULE_OP_MANGLE_APPEND
:
21226 rule_buf
[rule_pos
] = rule_cmd
;
21230 case RULE_OP_MANGLE_PREPEND
:
21231 rule_buf
[rule_pos
] = rule_cmd
;
21235 case RULE_OP_MANGLE_DELETE_FIRST
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21239 case RULE_OP_MANGLE_DELETE_LAST
:
21240 rule_buf
[rule_pos
] = rule_cmd
;
21243 case RULE_OP_MANGLE_DELETE_AT
:
21244 rule_buf
[rule_pos
] = rule_cmd
;
21245 GET_P0_CONV (rule
);
21248 case RULE_OP_MANGLE_EXTRACT
:
21249 rule_buf
[rule_pos
] = rule_cmd
;
21250 GET_P0_CONV (rule
);
21251 GET_P1_CONV (rule
);
21254 case RULE_OP_MANGLE_OMIT
:
21255 rule_buf
[rule_pos
] = rule_cmd
;
21256 GET_P0_CONV (rule
);
21257 GET_P1_CONV (rule
);
21260 case RULE_OP_MANGLE_INSERT
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21262 GET_P0_CONV (rule
);
21266 case RULE_OP_MANGLE_OVERSTRIKE
:
21267 rule_buf
[rule_pos
] = rule_cmd
;
21268 GET_P0_CONV (rule
);
21272 case RULE_OP_MANGLE_TRUNCATE_AT
:
21273 rule_buf
[rule_pos
] = rule_cmd
;
21274 GET_P0_CONV (rule
);
21277 case RULE_OP_MANGLE_REPLACE
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21283 case RULE_OP_MANGLE_PURGECHAR
:
21287 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21291 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21292 rule_buf
[rule_pos
] = rule_cmd
;
21293 GET_P0_CONV (rule
);
21296 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21297 rule_buf
[rule_pos
] = rule_cmd
;
21298 GET_P0_CONV (rule
);
21301 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21302 rule_buf
[rule_pos
] = rule_cmd
;
21305 case RULE_OP_MANGLE_SWITCH_FIRST
:
21306 rule_buf
[rule_pos
] = rule_cmd
;
21309 case RULE_OP_MANGLE_SWITCH_LAST
:
21310 rule_buf
[rule_pos
] = rule_cmd
;
21313 case RULE_OP_MANGLE_SWITCH_AT
:
21314 rule_buf
[rule_pos
] = rule_cmd
;
21315 GET_P0_CONV (rule
);
21316 GET_P1_CONV (rule
);
21319 case RULE_OP_MANGLE_CHR_SHIFTL
:
21320 rule_buf
[rule_pos
] = rule_cmd
;
21321 GET_P0_CONV (rule
);
21324 case RULE_OP_MANGLE_CHR_SHIFTR
:
21325 rule_buf
[rule_pos
] = rule_cmd
;
21326 GET_P0_CONV (rule
);
21329 case RULE_OP_MANGLE_CHR_INCR
:
21330 rule_buf
[rule_pos
] = rule_cmd
;
21331 GET_P0_CONV (rule
);
21334 case RULE_OP_MANGLE_CHR_DECR
:
21335 rule_buf
[rule_pos
] = rule_cmd
;
21336 GET_P0_CONV (rule
);
21339 case RULE_OP_MANGLE_REPLACE_NP1
:
21340 rule_buf
[rule_pos
] = rule_cmd
;
21341 GET_P0_CONV (rule
);
21344 case RULE_OP_MANGLE_REPLACE_NM1
:
21345 rule_buf
[rule_pos
] = rule_cmd
;
21346 GET_P0_CONV (rule
);
21349 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21350 rule_buf
[rule_pos
] = rule_cmd
;
21351 GET_P0_CONV (rule
);
21354 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21355 rule_buf
[rule_pos
] = rule_cmd
;
21356 GET_P0_CONV (rule
);
21359 case RULE_OP_MANGLE_TITLE
:
21360 rule_buf
[rule_pos
] = rule_cmd
;
21364 return rule_pos
- 1;
21382 * CPU rules : this is from hashcat sources, cpu based rules
21385 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21386 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21388 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21389 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21390 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21392 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21393 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21394 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21396 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21400 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21405 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21409 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21414 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21418 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21423 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21428 for (l
= 0; l
< arr_len
; l
++)
21430 r
= arr_len
- 1 - l
;
21434 MANGLE_SWITCH (arr
, l
, r
);
21440 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21442 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21444 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21446 return (arr_len
* 2);
21449 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21451 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21453 int orig_len
= arr_len
;
21457 for (i
= 0; i
< times
; i
++)
21459 memcpy (&arr
[arr_len
], arr
, orig_len
);
21461 arr_len
+= orig_len
;
21467 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21469 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21471 mangle_double (arr
, arr_len
);
21473 mangle_reverse (arr
+ arr_len
, arr_len
);
21475 return (arr_len
* 2);
21478 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21483 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21485 MANGLE_SWITCH (arr
, l
, r
);
21491 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21496 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21498 MANGLE_SWITCH (arr
, l
, r
);
21504 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21506 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21510 return (arr_len
+ 1);
21513 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21515 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21519 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21521 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21526 return (arr_len
+ 1);
21529 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21531 if (upos
>= arr_len
) return (arr_len
);
21535 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21537 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21540 return (arr_len
- 1);
21543 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21545 if (upos
>= arr_len
) return (arr_len
);
21547 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21551 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21553 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21559 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21561 if (upos
>= arr_len
) return (arr_len
);
21563 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21567 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21569 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21572 return (arr_len
- ulen
);
21575 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21577 if (upos
>= arr_len
) return (arr_len
);
21579 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21583 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21585 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21590 return (arr_len
+ 1);
21593 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
)
21595 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21597 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21599 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21601 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21603 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21605 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21607 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21609 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21611 return (arr_len
+ arr2_cpy
);
21614 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21616 if (upos
>= arr_len
) return (arr_len
);
21623 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21625 if (upos
>= arr_len
) return (arr_len
);
21627 memset (arr
+ upos
, 0, arr_len
- upos
);
21632 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21636 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21638 if (arr
[arr_pos
] != oldc
) continue;
21640 arr
[arr_pos
] = newc
;
21646 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21652 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21654 if (arr
[arr_pos
] == c
) continue;
21656 arr
[ret_len
] = arr
[arr_pos
];
21664 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21666 if (ulen
> arr_len
) return (arr_len
);
21668 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21670 char cs
[100] = { 0 };
21672 memcpy (cs
, arr
, ulen
);
21676 for (i
= 0; i
< ulen
; i
++)
21680 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21686 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21688 if (ulen
> arr_len
) return (arr_len
);
21690 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21692 int upos
= arr_len
- ulen
;
21696 for (i
= 0; i
< ulen
; i
++)
21698 char c
= arr
[upos
+ i
];
21700 arr_len
= mangle_append (arr
, arr_len
, c
);
21706 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21708 if ( arr_len
== 0) return (arr_len
);
21709 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21711 char c
= arr
[upos
];
21715 for (i
= 0; i
< ulen
; i
++)
21717 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21723 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21725 if ( arr_len
== 0) return (arr_len
);
21726 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21730 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21732 int new_pos
= arr_pos
* 2;
21734 arr
[new_pos
] = arr
[arr_pos
];
21736 arr
[new_pos
+ 1] = arr
[arr_pos
];
21739 return (arr_len
* 2);
21742 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21744 if (upos
>= arr_len
) return (arr_len
);
21745 if (upos2
>= arr_len
) return (arr_len
);
21747 MANGLE_SWITCH (arr
, upos
, upos2
);
21752 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21754 MANGLE_SWITCH (arr
, upos
, upos2
);
21759 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21761 if (upos
>= arr_len
) return (arr_len
);
21768 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21770 if (upos
>= arr_len
) return (arr_len
);
21777 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21779 if (upos
>= arr_len
) return (arr_len
);
21786 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21788 if (upos
>= arr_len
) return (arr_len
);
21795 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21797 int upper_next
= 1;
21801 for (pos
= 0; pos
< arr_len
; pos
++)
21803 if (arr
[pos
] == ' ')
21814 MANGLE_UPPER_AT (arr
, pos
);
21818 MANGLE_LOWER_AT (arr
, pos
);
21825 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21827 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21833 for (j
= 0; j
< rp_gen_num
; j
++)
21840 switch ((char) get_random_num (0, 9))
21843 r
= get_random_num (0, sizeof (grp_op_nop
));
21844 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21848 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21849 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21850 p1
= get_random_num (0, sizeof (grp_pos
));
21851 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21855 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21856 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21857 p1
= get_random_num (1, 6);
21858 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21862 r
= get_random_num (0, sizeof (grp_op_chr
));
21863 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21864 p1
= get_random_num (0x20, 0x7e);
21865 rule_buf
[rule_pos
++] = (char) p1
;
21869 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21870 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21871 p1
= get_random_num (0x20, 0x7e);
21872 rule_buf
[rule_pos
++] = (char) p1
;
21873 p2
= get_random_num (0x20, 0x7e);
21875 p2
= get_random_num (0x20, 0x7e);
21876 rule_buf
[rule_pos
++] = (char) p2
;
21880 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21881 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21882 p1
= get_random_num (0, sizeof (grp_pos
));
21883 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21884 p2
= get_random_num (0x20, 0x7e);
21885 rule_buf
[rule_pos
++] = (char) p2
;
21889 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21890 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21891 p1
= get_random_num (0, sizeof (grp_pos
));
21892 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21893 p2
= get_random_num (0, sizeof (grp_pos
));
21895 p2
= get_random_num (0, sizeof (grp_pos
));
21896 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21900 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21901 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21902 p1
= get_random_num (0, sizeof (grp_pos
));
21903 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21904 p2
= get_random_num (1, sizeof (grp_pos
));
21906 p2
= get_random_num (1, sizeof (grp_pos
));
21907 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21911 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21912 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21913 p1
= get_random_num (0, sizeof (grp_pos
));
21914 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21915 p2
= get_random_num (1, sizeof (grp_pos
));
21916 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21917 p3
= get_random_num (0, sizeof (grp_pos
));
21918 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21926 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21928 char mem
[BLOCK_SIZE
] = { 0 };
21930 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21932 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21934 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21936 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21938 int out_len
= in_len
;
21939 int mem_len
= in_len
;
21941 memcpy (out
, in
, out_len
);
21945 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21950 switch (rule
[rule_pos
])
21955 case RULE_OP_MANGLE_NOOP
:
21958 case RULE_OP_MANGLE_LREST
:
21959 out_len
= mangle_lrest (out
, out_len
);
21962 case RULE_OP_MANGLE_UREST
:
21963 out_len
= mangle_urest (out
, out_len
);
21966 case RULE_OP_MANGLE_LREST_UFIRST
:
21967 out_len
= mangle_lrest (out
, out_len
);
21968 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21971 case RULE_OP_MANGLE_UREST_LFIRST
:
21972 out_len
= mangle_urest (out
, out_len
);
21973 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21976 case RULE_OP_MANGLE_TREST
:
21977 out_len
= mangle_trest (out
, out_len
);
21980 case RULE_OP_MANGLE_TOGGLE_AT
:
21981 NEXT_RULEPOS (rule_pos
);
21982 NEXT_RPTOI (rule
, rule_pos
, upos
);
21983 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21986 case RULE_OP_MANGLE_REVERSE
:
21987 out_len
= mangle_reverse (out
, out_len
);
21990 case RULE_OP_MANGLE_DUPEWORD
:
21991 out_len
= mangle_double (out
, out_len
);
21994 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21995 NEXT_RULEPOS (rule_pos
);
21996 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21997 out_len
= mangle_double_times (out
, out_len
, ulen
);
22000 case RULE_OP_MANGLE_REFLECT
:
22001 out_len
= mangle_reflect (out
, out_len
);
22004 case RULE_OP_MANGLE_ROTATE_LEFT
:
22005 mangle_rotate_left (out
, out_len
);
22008 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22009 mangle_rotate_right (out
, out_len
);
22012 case RULE_OP_MANGLE_APPEND
:
22013 NEXT_RULEPOS (rule_pos
);
22014 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22017 case RULE_OP_MANGLE_PREPEND
:
22018 NEXT_RULEPOS (rule_pos
);
22019 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22022 case RULE_OP_MANGLE_DELETE_FIRST
:
22023 out_len
= mangle_delete_at (out
, out_len
, 0);
22026 case RULE_OP_MANGLE_DELETE_LAST
:
22027 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22030 case RULE_OP_MANGLE_DELETE_AT
:
22031 NEXT_RULEPOS (rule_pos
);
22032 NEXT_RPTOI (rule
, rule_pos
, upos
);
22033 out_len
= mangle_delete_at (out
, out_len
, upos
);
22036 case RULE_OP_MANGLE_EXTRACT
:
22037 NEXT_RULEPOS (rule_pos
);
22038 NEXT_RPTOI (rule
, rule_pos
, upos
);
22039 NEXT_RULEPOS (rule_pos
);
22040 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22041 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22044 case RULE_OP_MANGLE_OMIT
:
22045 NEXT_RULEPOS (rule_pos
);
22046 NEXT_RPTOI (rule
, rule_pos
, upos
);
22047 NEXT_RULEPOS (rule_pos
);
22048 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22049 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22052 case RULE_OP_MANGLE_INSERT
:
22053 NEXT_RULEPOS (rule_pos
);
22054 NEXT_RPTOI (rule
, rule_pos
, upos
);
22055 NEXT_RULEPOS (rule_pos
);
22056 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22059 case RULE_OP_MANGLE_OVERSTRIKE
:
22060 NEXT_RULEPOS (rule_pos
);
22061 NEXT_RPTOI (rule
, rule_pos
, upos
);
22062 NEXT_RULEPOS (rule_pos
);
22063 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22066 case RULE_OP_MANGLE_TRUNCATE_AT
:
22067 NEXT_RULEPOS (rule_pos
);
22068 NEXT_RPTOI (rule
, rule_pos
, upos
);
22069 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22072 case RULE_OP_MANGLE_REPLACE
:
22073 NEXT_RULEPOS (rule_pos
);
22074 NEXT_RULEPOS (rule_pos
);
22075 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22078 case RULE_OP_MANGLE_PURGECHAR
:
22079 NEXT_RULEPOS (rule_pos
);
22080 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22083 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22087 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22088 NEXT_RULEPOS (rule_pos
);
22089 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22090 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22093 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22094 NEXT_RULEPOS (rule_pos
);
22095 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22096 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22099 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22100 out_len
= mangle_dupechar (out
, out_len
);
22103 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22104 NEXT_RULEPOS (rule_pos
);
22105 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22106 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22109 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22110 NEXT_RULEPOS (rule_pos
);
22111 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22112 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22115 case RULE_OP_MANGLE_SWITCH_FIRST
:
22116 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22119 case RULE_OP_MANGLE_SWITCH_LAST
:
22120 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22123 case RULE_OP_MANGLE_SWITCH_AT
:
22124 NEXT_RULEPOS (rule_pos
);
22125 NEXT_RPTOI (rule
, rule_pos
, upos
);
22126 NEXT_RULEPOS (rule_pos
);
22127 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22128 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22131 case RULE_OP_MANGLE_CHR_SHIFTL
:
22132 NEXT_RULEPOS (rule_pos
);
22133 NEXT_RPTOI (rule
, rule_pos
, upos
);
22134 mangle_chr_shiftl (out
, out_len
, upos
);
22137 case RULE_OP_MANGLE_CHR_SHIFTR
:
22138 NEXT_RULEPOS (rule_pos
);
22139 NEXT_RPTOI (rule
, rule_pos
, upos
);
22140 mangle_chr_shiftr (out
, out_len
, upos
);
22143 case RULE_OP_MANGLE_CHR_INCR
:
22144 NEXT_RULEPOS (rule_pos
);
22145 NEXT_RPTOI (rule
, rule_pos
, upos
);
22146 mangle_chr_incr (out
, out_len
, upos
);
22149 case RULE_OP_MANGLE_CHR_DECR
:
22150 NEXT_RULEPOS (rule_pos
);
22151 NEXT_RPTOI (rule
, rule_pos
, upos
);
22152 mangle_chr_decr (out
, out_len
, upos
);
22155 case RULE_OP_MANGLE_REPLACE_NP1
:
22156 NEXT_RULEPOS (rule_pos
);
22157 NEXT_RPTOI (rule
, rule_pos
, upos
);
22158 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22161 case RULE_OP_MANGLE_REPLACE_NM1
:
22162 NEXT_RULEPOS (rule_pos
);
22163 NEXT_RPTOI (rule
, rule_pos
, upos
);
22164 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22167 case RULE_OP_MANGLE_TITLE
:
22168 out_len
= mangle_title (out
, out_len
);
22171 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22172 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22173 NEXT_RULEPOS (rule_pos
);
22174 NEXT_RPTOI (rule
, rule_pos
, upos
);
22175 NEXT_RULEPOS (rule_pos
);
22176 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22177 NEXT_RULEPOS (rule_pos
);
22178 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22179 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22182 case RULE_OP_MANGLE_APPEND_MEMORY
:
22183 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22184 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22185 memcpy (out
+ out_len
, mem
, mem_len
);
22186 out_len
+= mem_len
;
22189 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22190 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22191 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22192 memcpy (mem
+ mem_len
, out
, out_len
);
22193 out_len
+= mem_len
;
22194 memcpy (out
, mem
, out_len
);
22197 case RULE_OP_MEMORIZE_WORD
:
22198 memcpy (mem
, out
, out_len
);
22202 case RULE_OP_REJECT_LESS
:
22203 NEXT_RULEPOS (rule_pos
);
22204 NEXT_RPTOI (rule
, rule_pos
, upos
);
22205 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22208 case RULE_OP_REJECT_GREATER
:
22209 NEXT_RULEPOS (rule_pos
);
22210 NEXT_RPTOI (rule
, rule_pos
, upos
);
22211 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22214 case RULE_OP_REJECT_CONTAIN
:
22215 NEXT_RULEPOS (rule_pos
);
22216 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22219 case RULE_OP_REJECT_NOT_CONTAIN
:
22220 NEXT_RULEPOS (rule_pos
);
22221 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22224 case RULE_OP_REJECT_EQUAL_FIRST
:
22225 NEXT_RULEPOS (rule_pos
);
22226 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22229 case RULE_OP_REJECT_EQUAL_LAST
:
22230 NEXT_RULEPOS (rule_pos
);
22231 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22234 case RULE_OP_REJECT_EQUAL_AT
:
22235 NEXT_RULEPOS (rule_pos
);
22236 NEXT_RPTOI (rule
, rule_pos
, upos
);
22237 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22238 NEXT_RULEPOS (rule_pos
);
22239 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22242 case RULE_OP_REJECT_CONTAINS
:
22243 NEXT_RULEPOS (rule_pos
);
22244 NEXT_RPTOI (rule
, rule_pos
, upos
);
22245 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22246 NEXT_RULEPOS (rule_pos
);
22247 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22248 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22251 case RULE_OP_REJECT_MEMORY
:
22252 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22256 return (RULE_RC_SYNTAX_ERROR
);
22261 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);