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 termios savemodes
;
2338 static int havemodes
= 0;
2342 struct termios modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
3406 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonGpuIdle
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonApplicationsClocksSetting
;
3408 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3410 if (data
.kernel_power_final
)
3412 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonHwSlowdown
;
3415 return (clocksThrottleReasons
!= nvmlClocksThrottleReasonNone
);
3421 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3423 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3429 if (data
.hm_device
[device_id
].od_version
== 5)
3431 ADLFanSpeedValue lpFanSpeedValue
;
3433 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3435 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3436 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3437 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3438 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3440 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3444 else // od_version == 6
3446 ADLOD6FanSpeedValue fan_speed_value
;
3448 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3450 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3451 fan_speed_value
.iFanSpeed
= fanspeed
;
3453 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3460 if (data
.hm_device
[device_id
].od_version
== 5)
3462 if (hm_ADL_Overdrive5_FanSpeedToDefault_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0) != ADL_OK
) return -1;
3466 else // od_version == 6
3468 if (hm_ADL_Overdrive6_FanSpeed_Reset (data
.hm_adl
, data
.hm_device
[device_id
].adl
) != ADL_OK
) return -1;
3479 int hm_set_fanspeed_with_device_id_nvapi (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3481 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3487 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3489 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3491 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3492 CoolerLevels
.Levels
[0].Policy
= 1;
3494 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3500 if (hm_NvAPI_GPU_RestoreCoolerSettings (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0) != NVAPI_OK
) return -1;
3510 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3512 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3514 if (data
.hm_xnvctrl
)
3516 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3525 #endif // HAVE_HWMON
3531 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3533 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3535 if (css_cnt
> SP_PW_MAX
)
3537 log_error ("ERROR: Mask length is too long");
3542 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3544 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3546 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3547 uint cs_len
= css
[css_pos
].cs_len
;
3549 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3551 uint c
= cs_buf
[cs_pos
] & 0xff;
3558 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3560 cs_t
*cs
= &css
[css_cnt
];
3562 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3564 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3568 for (i
= 0; i
< cs
->cs_len
; i
++)
3570 const uint u
= cs
->cs_buf
[i
];
3575 for (i
= 0; i
< in_len
; i
++)
3577 uint u
= in_buf
[i
] & 0xff;
3579 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3581 if (css_uniq
[u
] == 1) continue;
3585 cs
->cs_buf
[cs
->cs_len
] = u
;
3593 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3597 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3599 uint p0
= in_buf
[in_pos
] & 0xff;
3601 if (interpret
== 1 && p0
== '?')
3605 if (in_pos
== in_len
) break;
3607 uint p1
= in_buf
[in_pos
] & 0xff;
3611 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3613 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3615 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3617 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3619 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3621 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3623 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3624 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3626 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3627 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3629 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3630 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3632 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3633 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3635 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3637 default: log_error ("Syntax error: %s", in_buf
);
3643 if (data
.hex_charset
)
3647 if (in_pos
== in_len
)
3649 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3654 uint p1
= in_buf
[in_pos
] & 0xff;
3656 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3658 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3665 chr
= hex_convert (p1
) << 0;
3666 chr
|= hex_convert (p0
) << 4;
3668 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3674 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3680 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3684 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3686 sum
*= css
[css_pos
].cs_len
;
3692 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3694 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3699 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3701 char p0
= mask_buf
[mask_pos
];
3707 if (mask_pos
== mask_len
) break;
3709 char p1
= mask_buf
[mask_pos
];
3715 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3717 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3719 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3721 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3723 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3725 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3727 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3728 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3730 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3731 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3733 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3734 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3736 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3737 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3739 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3741 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3747 if (data
.hex_charset
)
3751 // if there is no 2nd hex character, show an error:
3753 if (mask_pos
== mask_len
)
3755 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3760 char p1
= mask_buf
[mask_pos
];
3762 // if they are not valid hex character, show an error:
3764 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3766 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3773 chr
|= hex_convert (p1
) << 0;
3774 chr
|= hex_convert (p0
) << 4;
3776 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3782 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3789 log_error ("ERROR: Invalid mask length (0)");
3799 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3801 for (int i
= 0; i
< css_cnt
; i
++)
3803 uint len
= css
[i
].cs_len
;
3804 u64 next
= val
/ len
;
3805 uint pos
= val
% len
;
3806 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3811 void mp_cut_at (char *mask
, uint max
)
3815 uint mask_len
= strlen (mask
);
3817 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3819 if (mask
[i
] == '?') i
++;
3825 void mp_setup_sys (cs_t
*mp_sys
)
3829 uint donec
[CHARSIZ
] = { 0 };
3831 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3832 mp_sys
[0].cs_buf
[pos
++] = chr
;
3833 mp_sys
[0].cs_len
= pos
; }
3835 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3836 mp_sys
[1].cs_buf
[pos
++] = chr
;
3837 mp_sys
[1].cs_len
= pos
; }
3839 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3840 mp_sys
[2].cs_buf
[pos
++] = chr
;
3841 mp_sys
[2].cs_len
= pos
; }
3843 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3844 mp_sys
[3].cs_buf
[pos
++] = chr
;
3845 mp_sys
[3].cs_len
= pos
; }
3847 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3848 mp_sys
[4].cs_len
= pos
; }
3850 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3851 mp_sys
[5].cs_len
= pos
; }
3854 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3856 FILE *fp
= fopen (buf
, "rb");
3858 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3860 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3864 char mp_file
[1024] = { 0 };
3866 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3870 len
= in_superchop (mp_file
);
3874 log_info ("WARNING: Charset file corrupted");
3876 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3880 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3885 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3887 mp_usr
[index
].cs_len
= 0;
3889 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3892 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3894 char *new_mask_buf
= (char *) mymalloc (256);
3900 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3902 if (css_pos
== len
) break;
3904 char p0
= mask_buf
[mask_pos
];
3906 new_mask_buf
[mask_pos
] = p0
;
3912 if (mask_pos
== mask_len
) break;
3914 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3918 if (data
.hex_charset
)
3922 if (mask_pos
== mask_len
)
3924 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3929 char p1
= mask_buf
[mask_pos
];
3931 // if they are not valid hex character, show an error:
3933 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3935 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3940 new_mask_buf
[mask_pos
] = p1
;
3945 if (css_pos
== len
) return (new_mask_buf
);
3947 myfree (new_mask_buf
);
3956 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3962 for (i
= start
; i
< stop
; i
++)
3964 sum
*= root_css_buf
[i
].cs_len
;
3970 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3974 cs_t
*cs
= &root_css_buf
[start
];
3978 for (i
= start
; i
< stop
; i
++)
3980 const u64 m
= v
% cs
->cs_len
;
3981 const u64 d
= v
/ cs
->cs_len
;
3985 const uint k
= cs
->cs_buf
[m
];
3987 pw_buf
[i
- start
] = (char) k
;
3989 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3993 int sp_comp_val (const void *p1
, const void *p2
)
3995 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3996 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3998 return b2
->val
- b1
->val
;
4001 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
4008 * Initialize hcstats
4011 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4013 u64
*root_stats_ptr
= root_stats_buf
;
4015 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4017 for (i
= 0; i
< SP_PW_MAX
; i
++)
4019 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4021 root_stats_ptr
+= CHARSIZ
;
4024 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4026 u64
*markov_stats_ptr
= markov_stats_buf
;
4028 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4030 for (i
= 0; i
< SP_PW_MAX
; i
++)
4032 for (j
= 0; j
< CHARSIZ
; j
++)
4034 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4036 markov_stats_ptr
+= CHARSIZ
;
4046 char hcstat_tmp
[256] = { 0 };
4048 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4050 hcstat
= hcstat_tmp
;
4053 FILE *fd
= fopen (hcstat
, "rb");
4057 log_error ("%s: %s", hcstat
, strerror (errno
));
4062 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4064 log_error ("%s: Could not load data", hcstat
);
4071 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4073 log_error ("%s: Could not load data", hcstat
);
4083 * Markov modifier of hcstat_table on user request
4088 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4089 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4094 /* Add all stats to first position */
4096 for (i
= 1; i
< SP_PW_MAX
; i
++)
4098 u64
*out
= root_stats_buf_by_pos
[0];
4099 u64
*in
= root_stats_buf_by_pos
[i
];
4101 for (j
= 0; j
< CHARSIZ
; j
++)
4107 for (i
= 1; i
< SP_PW_MAX
; i
++)
4109 u64
*out
= markov_stats_buf_by_key
[0][0];
4110 u64
*in
= markov_stats_buf_by_key
[i
][0];
4112 for (j
= 0; j
< CHARSIZ
; j
++)
4114 for (k
= 0; k
< CHARSIZ
; k
++)
4121 /* copy them to all pw_positions */
4123 for (i
= 1; i
< SP_PW_MAX
; i
++)
4125 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4128 for (i
= 1; i
< SP_PW_MAX
; i
++)
4130 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4138 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4140 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4142 for (i
= 0; i
< SP_PW_MAX
; i
++)
4144 root_table_buf_by_pos
[i
] = root_table_ptr
;
4146 root_table_ptr
+= CHARSIZ
;
4149 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4151 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4153 for (i
= 0; i
< SP_PW_MAX
; i
++)
4155 for (j
= 0; j
< CHARSIZ
; j
++)
4157 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4159 markov_table_ptr
+= CHARSIZ
;
4164 * Convert hcstat to tables
4167 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4169 uint key
= i
% CHARSIZ
;
4171 root_table_buf
[i
].key
= key
;
4172 root_table_buf
[i
].val
= root_stats_buf
[i
];
4175 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4177 uint key
= i
% CHARSIZ
;
4179 markov_table_buf
[i
].key
= key
;
4180 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4183 myfree (root_stats_buf
);
4184 myfree (markov_stats_buf
);
4190 for (i
= 0; i
< SP_PW_MAX
; i
++)
4192 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4195 for (i
= 0; i
< SP_PW_MAX
; i
++)
4197 for (j
= 0; j
< CHARSIZ
; j
++)
4199 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4204 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4207 * Convert tables to css
4210 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4212 uint pw_pos
= i
/ CHARSIZ
;
4214 cs_t
*cs
= &root_css_buf
[pw_pos
];
4216 if (cs
->cs_len
== threshold
) continue;
4218 uint key
= root_table_buf
[i
].key
;
4220 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4222 cs
->cs_buf
[cs
->cs_len
] = key
;
4228 * Convert table to css
4231 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4233 uint c
= i
/ CHARSIZ
;
4235 cs_t
*cs
= &markov_css_buf
[c
];
4237 if (cs
->cs_len
== threshold
) continue;
4239 uint pw_pos
= c
/ CHARSIZ
;
4241 uint key
= markov_table_buf
[i
].key
;
4243 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4245 cs
->cs_buf
[cs
->cs_len
] = key
;
4251 for (uint i = 0; i < 8; i++)
4253 for (uint j = 0x20; j < 0x80; j++)
4255 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4257 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4259 for (uint k = 0; k < 10; k++)
4261 printf (" %u\n", ptr->cs_buf[k]);
4268 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4270 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4272 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4282 for (uint j
= 1; j
< CHARSIZ
; j
++)
4292 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4294 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4296 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4298 out
+= CHARSIZ
* CHARSIZ
;
4299 in
+= CHARSIZ
* CHARSIZ
;
4301 for (uint j
= 0; j
< CHARSIZ
; j
++)
4308 for (uint k
= 1; k
< CHARSIZ
; k
++)
4320 * mixed shared functions
4323 void dump_hex (const u8
*s
, const int sz
)
4325 for (int i
= 0; i
< sz
; i
++)
4327 log_info_nn ("%02x ", s
[i
]);
4333 void usage_mini_print (const char *progname
)
4335 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4338 void usage_big_print (const char *progname
)
4340 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4343 char *get_exec_path ()
4345 int exec_path_len
= 1024;
4347 char *exec_path
= (char *) mymalloc (exec_path_len
);
4351 char tmp
[32] = { 0 };
4353 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4355 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4359 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4363 uint size
= exec_path_len
;
4365 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4367 log_error("! executable path buffer too small\n");
4372 const int len
= strlen (exec_path
);
4375 #error Your Operating System is not supported or detected
4383 char *get_install_dir (const char *progname
)
4385 char *install_dir
= mystrdup (progname
);
4386 char *last_slash
= NULL
;
4388 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4392 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4398 install_dir
[0] = '.';
4402 return (install_dir
);
4405 char *get_profile_dir (const char *homedir
)
4407 #define DOT_HASHCAT ".hashcat"
4409 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4411 char *profile_dir
= (char *) mymalloc (len
+ 1);
4413 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4418 char *get_session_dir (const char *profile_dir
)
4420 #define SESSIONS_FOLDER "sessions"
4422 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4424 char *session_dir
= (char *) mymalloc (len
+ 1);
4426 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4431 uint
count_lines (FILE *fd
)
4435 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4441 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4443 if (nread
< 1) continue;
4447 for (i
= 0; i
< nread
; i
++)
4449 if (prev
== '\n') cnt
++;
4460 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4464 FILE *fd
= fopen (filename
, "rb");
4468 log_error ("%s: %s", filename
, strerror (errno
));
4473 #define MAX_KEY_SIZE (1024 * 1024)
4475 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4477 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4483 for (int fpos
= 0; fpos
< nread
; fpos
++)
4485 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4487 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4488 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4489 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4490 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4492 if (kpos
>= 64) kpos
= 0;
4499 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4503 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4504 if (CPU_ISSET(core
, cpu_set
)) break;
4506 thread_affinity_policy_data_t policy
= { core
};
4508 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4510 if (data
.quiet
== 0)
4512 if (rc
!= KERN_SUCCESS
)
4514 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4522 void set_cpu_affinity (char *cpu_affinity
)
4525 DWORD_PTR aff_mask
= 0;
4533 char *devices
= strdup (cpu_affinity
);
4535 char *next
= strtok (devices
, ",");
4539 uint cpu_id
= atoi (next
);
4554 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4560 aff_mask
|= 1 << (cpu_id
- 1);
4562 CPU_SET ((cpu_id
- 1), &cpuset
);
4565 } while ((next
= strtok (NULL
, ",")) != NULL
);
4571 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4572 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4574 pthread_t thread
= pthread_self ();
4575 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4579 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4581 char *element
, *end
;
4583 end
= (char *) base
+ nmemb
* size
;
4585 for (element
= (char *) base
; element
< end
; element
+= size
)
4586 if (!compar (element
, key
))
4592 int sort_by_u32 (const void *v1
, const void *v2
)
4594 const u32
*s1
= (const u32
*) v1
;
4595 const u32
*s2
= (const u32
*) v2
;
4600 int sort_by_salt (const void *v1
, const void *v2
)
4602 const salt_t
*s1
= (const salt_t
*) v1
;
4603 const salt_t
*s2
= (const salt_t
*) v2
;
4605 const int res1
= s1
->salt_len
- s2
->salt_len
;
4607 if (res1
!= 0) return (res1
);
4609 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4611 if (res2
!= 0) return (res2
);
4619 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4620 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4627 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4628 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4634 int sort_by_salt_buf (const void *v1
, const void *v2
)
4636 const pot_t
*p1
= (const pot_t
*) v1
;
4637 const pot_t
*p2
= (const pot_t
*) v2
;
4639 const hash_t
*h1
= &p1
->hash
;
4640 const hash_t
*h2
= &p2
->hash
;
4642 const salt_t
*s1
= h1
->salt
;
4643 const salt_t
*s2
= h2
->salt
;
4649 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4650 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4656 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4658 const hash_t
*h1
= (const hash_t
*) v1
;
4659 const hash_t
*h2
= (const hash_t
*) v2
;
4661 const salt_t
*s1
= h1
->salt
;
4662 const salt_t
*s2
= h2
->salt
;
4664 // testphase: this should work
4669 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4670 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4673 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4674 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4675 if (s1->salt_len > s2->salt_len) return ( 1);
4676 if (s1->salt_len < s2->salt_len) return (-1);
4678 uint n = s1->salt_len;
4682 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4683 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4690 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4692 const hash_t
*h1
= (const hash_t
*) v1
;
4693 const hash_t
*h2
= (const hash_t
*) v2
;
4695 const salt_t
*s1
= h1
->salt
;
4696 const salt_t
*s2
= h2
->salt
;
4698 // 16 - 2 (since last 2 uints contain the digest)
4703 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4704 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4710 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4712 const hash_t
*h1
= (const hash_t
*) v1
;
4713 const hash_t
*h2
= (const hash_t
*) v2
;
4715 const void *d1
= h1
->digest
;
4716 const void *d2
= h2
->digest
;
4718 return data
.sort_by_digest (d1
, d2
);
4721 int sort_by_hash (const void *v1
, const void *v2
)
4723 const hash_t
*h1
= (const hash_t
*) v1
;
4724 const hash_t
*h2
= (const hash_t
*) v2
;
4728 const salt_t
*s1
= h1
->salt
;
4729 const salt_t
*s2
= h2
->salt
;
4731 int res
= sort_by_salt (s1
, s2
);
4733 if (res
!= 0) return (res
);
4736 const void *d1
= h1
->digest
;
4737 const void *d2
= h2
->digest
;
4739 return data
.sort_by_digest (d1
, d2
);
4742 int sort_by_pot (const void *v1
, const void *v2
)
4744 const pot_t
*p1
= (const pot_t
*) v1
;
4745 const pot_t
*p2
= (const pot_t
*) v2
;
4747 const hash_t
*h1
= &p1
->hash
;
4748 const hash_t
*h2
= &p2
->hash
;
4750 return sort_by_hash (h1
, h2
);
4753 int sort_by_mtime (const void *p1
, const void *p2
)
4755 const char **f1
= (const char **) p1
;
4756 const char **f2
= (const char **) p2
;
4758 struct stat s1
; stat (*f1
, &s1
);
4759 struct stat s2
; stat (*f2
, &s2
);
4761 return s2
.st_mtime
- s1
.st_mtime
;
4764 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4766 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4767 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4769 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4772 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4774 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4775 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4777 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4780 int sort_by_stringptr (const void *p1
, const void *p2
)
4782 const char **s1
= (const char **) p1
;
4783 const char **s2
= (const char **) p2
;
4785 return strcmp (*s1
, *s2
);
4788 int sort_by_dictstat (const void *s1
, const void *s2
)
4790 dictstat_t
*d1
= (dictstat_t
*) s1
;
4791 dictstat_t
*d2
= (dictstat_t
*) s2
;
4794 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4796 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4799 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4802 int sort_by_bitmap (const void *p1
, const void *p2
)
4804 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4805 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4807 return b1
->collisions
- b2
->collisions
;
4810 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4812 const u32
*d1
= (const u32
*) v1
;
4813 const u32
*d2
= (const u32
*) v2
;
4819 if (d1
[n
] > d2
[n
]) return ( 1);
4820 if (d1
[n
] < d2
[n
]) return (-1);
4826 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4828 const u32
*d1
= (const u32
*) v1
;
4829 const u32
*d2
= (const u32
*) v2
;
4835 if (d1
[n
] > d2
[n
]) return ( 1);
4836 if (d1
[n
] < d2
[n
]) return (-1);
4842 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4844 const u32
*d1
= (const u32
*) v1
;
4845 const u32
*d2
= (const u32
*) v2
;
4851 if (d1
[n
] > d2
[n
]) return ( 1);
4852 if (d1
[n
] < d2
[n
]) return (-1);
4858 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4860 const u32
*d1
= (const u32
*) v1
;
4861 const u32
*d2
= (const u32
*) v2
;
4867 if (d1
[n
] > d2
[n
]) return ( 1);
4868 if (d1
[n
] < d2
[n
]) return (-1);
4874 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4876 const u32
*d1
= (const u32
*) v1
;
4877 const u32
*d2
= (const u32
*) v2
;
4883 if (d1
[n
] > d2
[n
]) return ( 1);
4884 if (d1
[n
] < d2
[n
]) return (-1);
4890 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4892 const u32
*d1
= (const u32
*) v1
;
4893 const u32
*d2
= (const u32
*) v2
;
4899 if (d1
[n
] > d2
[n
]) return ( 1);
4900 if (d1
[n
] < d2
[n
]) return (-1);
4906 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4908 const u32
*d1
= (const u32
*) v1
;
4909 const u32
*d2
= (const u32
*) v2
;
4915 if (d1
[n
] > d2
[n
]) return ( 1);
4916 if (d1
[n
] < d2
[n
]) return (-1);
4922 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4924 const u32
*d1
= (const u32
*) v1
;
4925 const u32
*d2
= (const u32
*) v2
;
4931 if (d1
[n
] > d2
[n
]) return ( 1);
4932 if (d1
[n
] < d2
[n
]) return (-1);
4938 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4940 const u64
*d1
= (const u64
*) v1
;
4941 const u64
*d2
= (const u64
*) v2
;
4947 if (d1
[n
] > d2
[n
]) return ( 1);
4948 if (d1
[n
] < d2
[n
]) return (-1);
4954 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4956 const u64
*d1
= (const u64
*) v1
;
4957 const u64
*d2
= (const u64
*) v2
;
4963 if (d1
[n
] > d2
[n
]) return ( 1);
4964 if (d1
[n
] < d2
[n
]) return (-1);
4970 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4972 const u64
*d1
= (const u64
*) v1
;
4973 const u64
*d2
= (const u64
*) v2
;
4979 if (d1
[n
] > d2
[n
]) return ( 1);
4980 if (d1
[n
] < d2
[n
]) return (-1);
4986 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4988 const u32
*d1
= (const u32
*) v1
;
4989 const u32
*d2
= (const u32
*) v2
;
4991 const uint dgst_pos0
= data
.dgst_pos0
;
4992 const uint dgst_pos1
= data
.dgst_pos1
;
4993 const uint dgst_pos2
= data
.dgst_pos2
;
4994 const uint dgst_pos3
= data
.dgst_pos3
;
4996 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4997 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4998 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4999 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5000 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5001 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5002 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5003 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5008 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5010 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5011 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5013 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5015 if (res1
!= 0) return (res1
);
5020 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5022 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5023 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5025 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5027 if (res1
!= 0) return (res1
);
5029 const int res2
= t1
->attack_mode
5032 if (res2
!= 0) return (res2
);
5034 const int res3
= t1
->hash_type
5037 if (res3
!= 0) return (res3
);
5042 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
)
5044 uint outfile_autohex
= data
.outfile_autohex
;
5046 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5048 FILE *debug_fp
= NULL
;
5050 if (debug_file
!= NULL
)
5052 debug_fp
= fopen (debug_file
, "ab");
5054 lock_file (debug_fp
);
5061 if (debug_fp
== NULL
)
5063 log_info ("WARNING: Could not open debug-file for writing");
5067 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5069 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5071 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5074 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5076 if (debug_mode
== 4)
5078 fputc (':', debug_fp
);
5080 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5083 fputc ('\n', debug_fp
);
5085 if (debug_file
!= NULL
) fclose (debug_fp
);
5089 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5091 int needs_hexify
= 0;
5093 if (outfile_autohex
== 1)
5095 for (uint i
= 0; i
< plain_len
; i
++)
5097 if (plain_ptr
[i
] < 0x20)
5104 if (plain_ptr
[i
] > 0x7f)
5113 if (needs_hexify
== 1)
5115 fprintf (fp
, "$HEX[");
5117 for (uint i
= 0; i
< plain_len
; i
++)
5119 fprintf (fp
, "%02x", plain_ptr
[i
]);
5126 fwrite (plain_ptr
, plain_len
, 1, fp
);
5130 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
)
5132 uint outfile_format
= data
.outfile_format
;
5134 char separator
= data
.separator
;
5136 if (outfile_format
& OUTFILE_FMT_HASH
)
5138 fprintf (out_fp
, "%s", out_buf
);
5140 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5142 fputc (separator
, out_fp
);
5145 else if (data
.username
)
5147 if (username
!= NULL
)
5149 for (uint i
= 0; i
< user_len
; i
++)
5151 fprintf (out_fp
, "%c", username
[i
]);
5154 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5156 fputc (separator
, out_fp
);
5161 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5163 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5165 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5167 fputc (separator
, out_fp
);
5171 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5173 for (uint i
= 0; i
< plain_len
; i
++)
5175 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5178 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5180 fputc (separator
, out_fp
);
5184 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5187 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5192 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5194 fprintf (out_fp
, "%llu", crackpos
);
5199 fputc ('\n', out_fp
);
5202 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
)
5206 pot_key
.hash
.salt
= hashes_buf
->salt
;
5207 pot_key
.hash
.digest
= hashes_buf
->digest
;
5209 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5215 input_buf
[input_len
] = 0;
5218 unsigned char *username
= NULL
;
5223 user_t
*user
= hashes_buf
->hash_info
->user
;
5227 username
= (unsigned char *) (user
->user_name
);
5229 user_len
= user
->user_len
;
5233 // do output the line
5234 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5238 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5239 #define LM_MASKED_PLAIN "[notfound]"
5241 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
)
5247 pot_left_key
.hash
.salt
= hash_left
->salt
;
5248 pot_left_key
.hash
.digest
= hash_left
->digest
;
5250 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5254 uint weak_hash_found
= 0;
5256 pot_t pot_right_key
;
5258 pot_right_key
.hash
.salt
= hash_right
->salt
;
5259 pot_right_key
.hash
.digest
= hash_right
->digest
;
5261 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5263 if (pot_right_ptr
== NULL
)
5265 // special case, if "weak hash"
5267 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5269 weak_hash_found
= 1;
5271 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5273 // in theory this is not needed, but we are paranoia:
5275 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5276 pot_right_ptr
->plain_len
= 0;
5280 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5282 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
5287 // at least one half was found:
5291 input_buf
[input_len
] = 0;
5295 unsigned char *username
= NULL
;
5300 user_t
*user
= hash_left
->hash_info
->user
;
5304 username
= (unsigned char *) (user
->user_name
);
5306 user_len
= user
->user_len
;
5310 // mask the part which was not found
5312 uint left_part_masked
= 0;
5313 uint right_part_masked
= 0;
5315 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5317 if (pot_left_ptr
== NULL
)
5319 left_part_masked
= 1;
5321 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5323 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5325 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5326 pot_left_ptr
->plain_len
= mask_plain_len
;
5329 if (pot_right_ptr
== NULL
)
5331 right_part_masked
= 1;
5333 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5335 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5337 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5338 pot_right_ptr
->plain_len
= mask_plain_len
;
5341 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5345 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5347 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5349 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5351 // do output the line
5353 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5355 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5357 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5358 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5361 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
)
5365 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5367 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5369 if (pot_ptr
== NULL
)
5373 input_buf
[input_len
] = 0;
5375 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5379 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
)
5385 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5387 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5391 pot_t pot_right_key
;
5393 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5395 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5397 uint weak_hash_found
= 0;
5399 if (pot_right_ptr
== NULL
)
5401 // special case, if "weak hash"
5403 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5405 weak_hash_found
= 1;
5407 // we just need that pot_right_ptr is not a NULL pointer
5409 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5413 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5415 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5420 // ... at least one part was not cracked
5424 input_buf
[input_len
] = 0;
5426 // only show the hash part which is still not cracked
5428 uint user_len
= input_len
- 32;
5430 char *hash_output
= (char *) mymalloc (33);
5432 memcpy (hash_output
, input_buf
, input_len
);
5434 if (pot_left_ptr
!= NULL
)
5436 // only show right part (because left part was already found)
5438 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5440 hash_output
[user_len
+ 16] = 0;
5443 if (pot_right_ptr
!= NULL
)
5445 // only show left part (because right part was already found)
5447 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5449 hash_output
[user_len
+ 16] = 0;
5452 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5454 myfree (hash_output
);
5456 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5459 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5461 uint opencl_platforms_filter
= 0;
5463 if (opencl_platforms
)
5465 char *platforms
= strdup (opencl_platforms
);
5467 char *next
= strtok (platforms
, ",");
5471 int platform
= atoi (next
);
5473 if (platform
< 1 || platform
> 32)
5475 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5480 opencl_platforms_filter
|= 1 << (platform
- 1);
5482 } while ((next
= strtok (NULL
, ",")) != NULL
);
5488 opencl_platforms_filter
= -1;
5491 return opencl_platforms_filter
;
5494 u32
setup_devices_filter (char *opencl_devices
)
5496 u32 devices_filter
= 0;
5500 char *devices
= strdup (opencl_devices
);
5502 char *next
= strtok (devices
, ",");
5506 int device_id
= atoi (next
);
5508 if (device_id
< 1 || device_id
> 32)
5510 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5515 devices_filter
|= 1 << (device_id
- 1);
5517 } while ((next
= strtok (NULL
, ",")) != NULL
);
5523 devices_filter
= -1;
5526 return devices_filter
;
5529 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5531 cl_device_type device_types_filter
= 0;
5533 if (opencl_device_types
)
5535 char *device_types
= strdup (opencl_device_types
);
5537 char *next
= strtok (device_types
, ",");
5541 int device_type
= atoi (next
);
5543 if (device_type
< 1 || device_type
> 3)
5545 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5550 device_types_filter
|= 1 << device_type
;
5552 } while ((next
= strtok (NULL
, ",")) != NULL
);
5554 free (device_types
);
5558 // Do not use CPU by default, this often reduces GPU performance because
5559 // the CPU is too busy to handle GPU synchronization
5561 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5564 return device_types_filter
;
5567 u32
get_random_num (const u32 min
, const u32 max
)
5569 if (min
== max
) return (min
);
5571 return ((rand () % (max
- min
)) + min
);
5574 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5576 u32 quotient
= dividend
/ divisor
;
5578 if (dividend
% divisor
) quotient
++;
5583 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5585 u64 quotient
= dividend
/ divisor
;
5587 if (dividend
% divisor
) quotient
++;
5592 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5594 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5595 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5597 if (tm
->tm_year
- 70)
5599 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5600 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5602 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5604 else if (tm
->tm_yday
)
5606 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5607 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5609 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5611 else if (tm
->tm_hour
)
5613 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5614 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5616 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5618 else if (tm
->tm_min
)
5620 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5621 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5623 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5627 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5629 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5633 void format_speed_display (float val
, char *buf
, size_t len
)
5644 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5655 /* generate output */
5659 snprintf (buf
, len
- 1, "%.0f ", val
);
5663 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5667 void lowercase (u8
*buf
, int len
)
5669 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5672 void uppercase (u8
*buf
, int len
)
5674 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5677 int fgetl (FILE *fp
, char *line_buf
)
5683 const int c
= fgetc (fp
);
5685 if (c
== EOF
) break;
5687 line_buf
[line_len
] = (char) c
;
5691 if (line_len
== HCBUFSIZ
) line_len
--;
5693 if (c
== '\n') break;
5696 if (line_len
== 0) return 0;
5698 if (line_buf
[line_len
- 1] == '\n')
5702 line_buf
[line_len
] = 0;
5705 if (line_len
== 0) return 0;
5707 if (line_buf
[line_len
- 1] == '\r')
5711 line_buf
[line_len
] = 0;
5717 int in_superchop (char *buf
)
5719 int len
= strlen (buf
);
5723 if (buf
[len
- 1] == '\n')
5730 if (buf
[len
- 1] == '\r')
5745 char **scan_directory (const char *path
)
5747 char *tmp_path
= mystrdup (path
);
5749 size_t tmp_path_len
= strlen (tmp_path
);
5751 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5753 tmp_path
[tmp_path_len
- 1] = 0;
5755 tmp_path_len
= strlen (tmp_path
);
5758 char **files
= NULL
;
5764 if ((d
= opendir (tmp_path
)) != NULL
)
5770 memset (&e
, 0, sizeof (e
));
5771 struct dirent
*de
= NULL
;
5773 if (readdir_r (d
, &e
, &de
) != 0)
5775 log_error ("ERROR: readdir_r() failed");
5780 if (de
== NULL
) break;
5784 while ((de
= readdir (d
)) != NULL
)
5787 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5789 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5791 char *path_file
= (char *) mymalloc (path_size
+ 1);
5793 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5795 path_file
[path_size
] = 0;
5799 if ((d_test
= opendir (path_file
)) != NULL
)
5807 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5811 files
[num_files
- 1] = path_file
;
5817 else if (errno
== ENOTDIR
)
5819 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5823 files
[num_files
- 1] = mystrdup (path
);
5826 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5830 files
[num_files
- 1] = NULL
;
5837 int count_dictionaries (char **dictionary_files
)
5839 if (dictionary_files
== NULL
) return 0;
5843 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5851 char *stroptitype (const uint opti_type
)
5855 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5856 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5857 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5858 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5859 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5860 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5861 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5862 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5863 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5864 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5865 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5866 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5867 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5868 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5869 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5870 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5871 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5872 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5873 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5879 char *strparser (const uint parser_status
)
5881 switch (parser_status
)
5883 case PARSER_OK
: return ((char *) PA_000
); break;
5884 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5885 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5886 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5887 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5888 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5889 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5890 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5891 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5892 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5893 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5894 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5895 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5896 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5897 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5898 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5899 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5902 return ((char *) PA_255
);
5905 char *strhashtype (const uint hash_mode
)
5909 case 0: return ((char *) HT_00000
); break;
5910 case 10: return ((char *) HT_00010
); break;
5911 case 11: return ((char *) HT_00011
); break;
5912 case 12: return ((char *) HT_00012
); break;
5913 case 20: return ((char *) HT_00020
); break;
5914 case 21: return ((char *) HT_00021
); break;
5915 case 22: return ((char *) HT_00022
); break;
5916 case 23: return ((char *) HT_00023
); break;
5917 case 30: return ((char *) HT_00030
); break;
5918 case 40: return ((char *) HT_00040
); break;
5919 case 50: return ((char *) HT_00050
); break;
5920 case 60: return ((char *) HT_00060
); break;
5921 case 100: return ((char *) HT_00100
); break;
5922 case 101: return ((char *) HT_00101
); break;
5923 case 110: return ((char *) HT_00110
); break;
5924 case 111: return ((char *) HT_00111
); break;
5925 case 112: return ((char *) HT_00112
); break;
5926 case 120: return ((char *) HT_00120
); break;
5927 case 121: return ((char *) HT_00121
); break;
5928 case 122: return ((char *) HT_00122
); break;
5929 case 124: return ((char *) HT_00124
); break;
5930 case 125: return ((char *) HT_00125
); break;
5931 case 130: return ((char *) HT_00130
); break;
5932 case 131: return ((char *) HT_00131
); break;
5933 case 132: return ((char *) HT_00132
); break;
5934 case 133: return ((char *) HT_00133
); break;
5935 case 140: return ((char *) HT_00140
); break;
5936 case 141: return ((char *) HT_00141
); break;
5937 case 150: return ((char *) HT_00150
); break;
5938 case 160: return ((char *) HT_00160
); break;
5939 case 200: return ((char *) HT_00200
); break;
5940 case 300: return ((char *) HT_00300
); break;
5941 case 400: return ((char *) HT_00400
); break;
5942 case 500: return ((char *) HT_00500
); break;
5943 case 501: return ((char *) HT_00501
); break;
5944 case 900: return ((char *) HT_00900
); break;
5945 case 910: return ((char *) HT_00910
); break;
5946 case 1000: return ((char *) HT_01000
); break;
5947 case 1100: return ((char *) HT_01100
); break;
5948 case 1400: return ((char *) HT_01400
); break;
5949 case 1410: return ((char *) HT_01410
); break;
5950 case 1420: return ((char *) HT_01420
); break;
5951 case 1421: return ((char *) HT_01421
); break;
5952 case 1430: return ((char *) HT_01430
); break;
5953 case 1440: return ((char *) HT_01440
); break;
5954 case 1441: return ((char *) HT_01441
); break;
5955 case 1450: return ((char *) HT_01450
); break;
5956 case 1460: return ((char *) HT_01460
); break;
5957 case 1500: return ((char *) HT_01500
); break;
5958 case 1600: return ((char *) HT_01600
); break;
5959 case 1700: return ((char *) HT_01700
); break;
5960 case 1710: return ((char *) HT_01710
); break;
5961 case 1711: return ((char *) HT_01711
); break;
5962 case 1720: return ((char *) HT_01720
); break;
5963 case 1722: return ((char *) HT_01722
); break;
5964 case 1730: return ((char *) HT_01730
); break;
5965 case 1731: return ((char *) HT_01731
); break;
5966 case 1740: return ((char *) HT_01740
); break;
5967 case 1750: return ((char *) HT_01750
); break;
5968 case 1760: return ((char *) HT_01760
); break;
5969 case 1800: return ((char *) HT_01800
); break;
5970 case 2100: return ((char *) HT_02100
); break;
5971 case 2400: return ((char *) HT_02400
); break;
5972 case 2410: return ((char *) HT_02410
); break;
5973 case 2500: return ((char *) HT_02500
); break;
5974 case 2600: return ((char *) HT_02600
); break;
5975 case 2611: return ((char *) HT_02611
); break;
5976 case 2612: return ((char *) HT_02612
); break;
5977 case 2711: return ((char *) HT_02711
); break;
5978 case 2811: return ((char *) HT_02811
); break;
5979 case 3000: return ((char *) HT_03000
); break;
5980 case 3100: return ((char *) HT_03100
); break;
5981 case 3200: return ((char *) HT_03200
); break;
5982 case 3710: return ((char *) HT_03710
); break;
5983 case 3711: return ((char *) HT_03711
); break;
5984 case 3800: return ((char *) HT_03800
); break;
5985 case 4300: return ((char *) HT_04300
); break;
5986 case 4400: return ((char *) HT_04400
); break;
5987 case 4500: return ((char *) HT_04500
); break;
5988 case 4700: return ((char *) HT_04700
); break;
5989 case 4800: return ((char *) HT_04800
); break;
5990 case 4900: return ((char *) HT_04900
); break;
5991 case 5000: return ((char *) HT_05000
); break;
5992 case 5100: return ((char *) HT_05100
); break;
5993 case 5200: return ((char *) HT_05200
); break;
5994 case 5300: return ((char *) HT_05300
); break;
5995 case 5400: return ((char *) HT_05400
); break;
5996 case 5500: return ((char *) HT_05500
); break;
5997 case 5600: return ((char *) HT_05600
); break;
5998 case 5700: return ((char *) HT_05700
); break;
5999 case 5800: return ((char *) HT_05800
); break;
6000 case 6000: return ((char *) HT_06000
); break;
6001 case 6100: return ((char *) HT_06100
); break;
6002 case 6211: return ((char *) HT_06211
); break;
6003 case 6212: return ((char *) HT_06212
); break;
6004 case 6213: return ((char *) HT_06213
); break;
6005 case 6221: return ((char *) HT_06221
); break;
6006 case 6222: return ((char *) HT_06222
); break;
6007 case 6223: return ((char *) HT_06223
); break;
6008 case 6231: return ((char *) HT_06231
); break;
6009 case 6232: return ((char *) HT_06232
); break;
6010 case 6233: return ((char *) HT_06233
); break;
6011 case 6241: return ((char *) HT_06241
); break;
6012 case 6242: return ((char *) HT_06242
); break;
6013 case 6243: return ((char *) HT_06243
); break;
6014 case 6300: return ((char *) HT_06300
); break;
6015 case 6400: return ((char *) HT_06400
); break;
6016 case 6500: return ((char *) HT_06500
); break;
6017 case 6600: return ((char *) HT_06600
); break;
6018 case 6700: return ((char *) HT_06700
); break;
6019 case 6800: return ((char *) HT_06800
); break;
6020 case 6900: return ((char *) HT_06900
); break;
6021 case 7100: return ((char *) HT_07100
); break;
6022 case 7200: return ((char *) HT_07200
); break;
6023 case 7300: return ((char *) HT_07300
); break;
6024 case 7400: return ((char *) HT_07400
); break;
6025 case 7500: return ((char *) HT_07500
); break;
6026 case 7600: return ((char *) HT_07600
); break;
6027 case 7700: return ((char *) HT_07700
); break;
6028 case 7800: return ((char *) HT_07800
); break;
6029 case 7900: return ((char *) HT_07900
); break;
6030 case 8000: return ((char *) HT_08000
); break;
6031 case 8100: return ((char *) HT_08100
); break;
6032 case 8200: return ((char *) HT_08200
); break;
6033 case 8300: return ((char *) HT_08300
); break;
6034 case 8400: return ((char *) HT_08400
); break;
6035 case 8500: return ((char *) HT_08500
); break;
6036 case 8600: return ((char *) HT_08600
); break;
6037 case 8700: return ((char *) HT_08700
); break;
6038 case 8800: return ((char *) HT_08800
); break;
6039 case 8900: return ((char *) HT_08900
); break;
6040 case 9000: return ((char *) HT_09000
); break;
6041 case 9100: return ((char *) HT_09100
); break;
6042 case 9200: return ((char *) HT_09200
); break;
6043 case 9300: return ((char *) HT_09300
); break;
6044 case 9400: return ((char *) HT_09400
); break;
6045 case 9500: return ((char *) HT_09500
); break;
6046 case 9600: return ((char *) HT_09600
); break;
6047 case 9700: return ((char *) HT_09700
); break;
6048 case 9710: return ((char *) HT_09710
); break;
6049 case 9720: return ((char *) HT_09720
); break;
6050 case 9800: return ((char *) HT_09800
); break;
6051 case 9810: return ((char *) HT_09810
); break;
6052 case 9820: return ((char *) HT_09820
); break;
6053 case 9900: return ((char *) HT_09900
); break;
6054 case 10000: return ((char *) HT_10000
); break;
6055 case 10100: return ((char *) HT_10100
); break;
6056 case 10200: return ((char *) HT_10200
); break;
6057 case 10300: return ((char *) HT_10300
); break;
6058 case 10400: return ((char *) HT_10400
); break;
6059 case 10410: return ((char *) HT_10410
); break;
6060 case 10420: return ((char *) HT_10420
); break;
6061 case 10500: return ((char *) HT_10500
); break;
6062 case 10600: return ((char *) HT_10600
); break;
6063 case 10700: return ((char *) HT_10700
); break;
6064 case 10800: return ((char *) HT_10800
); break;
6065 case 10900: return ((char *) HT_10900
); break;
6066 case 11000: return ((char *) HT_11000
); break;
6067 case 11100: return ((char *) HT_11100
); break;
6068 case 11200: return ((char *) HT_11200
); break;
6069 case 11300: return ((char *) HT_11300
); break;
6070 case 11400: return ((char *) HT_11400
); break;
6071 case 11500: return ((char *) HT_11500
); break;
6072 case 11600: return ((char *) HT_11600
); break;
6073 case 11700: return ((char *) HT_11700
); break;
6074 case 11800: return ((char *) HT_11800
); break;
6075 case 11900: return ((char *) HT_11900
); break;
6076 case 12000: return ((char *) HT_12000
); break;
6077 case 12100: return ((char *) HT_12100
); break;
6078 case 12200: return ((char *) HT_12200
); break;
6079 case 12300: return ((char *) HT_12300
); break;
6080 case 12400: return ((char *) HT_12400
); break;
6081 case 12500: return ((char *) HT_12500
); break;
6082 case 12600: return ((char *) HT_12600
); break;
6083 case 12700: return ((char *) HT_12700
); break;
6084 case 12800: return ((char *) HT_12800
); break;
6085 case 12900: return ((char *) HT_12900
); break;
6086 case 13000: return ((char *) HT_13000
); break;
6087 case 13100: return ((char *) HT_13100
); break;
6088 case 13200: return ((char *) HT_13200
); break;
6089 case 13300: return ((char *) HT_13300
); break;
6090 case 13400: return ((char *) HT_13400
); break;
6091 case 13500: return ((char *) HT_13500
); break;
6092 case 13600: return ((char *) HT_13600
); break;
6093 case 13711: return ((char *) HT_13711
); break;
6094 case 13712: return ((char *) HT_13712
); break;
6095 case 13713: return ((char *) HT_13713
); break;
6096 case 13721: return ((char *) HT_13721
); break;
6097 case 13722: return ((char *) HT_13722
); break;
6098 case 13723: return ((char *) HT_13723
); break;
6099 case 13731: return ((char *) HT_13731
); break;
6100 case 13732: return ((char *) HT_13732
); break;
6101 case 13733: return ((char *) HT_13733
); break;
6102 case 13741: return ((char *) HT_13741
); break;
6103 case 13742: return ((char *) HT_13742
); break;
6104 case 13743: return ((char *) HT_13743
); break;
6105 case 13751: return ((char *) HT_13751
); break;
6106 case 13752: return ((char *) HT_13752
); break;
6107 case 13753: return ((char *) HT_13753
); break;
6108 case 13761: return ((char *) HT_13761
); break;
6109 case 13762: return ((char *) HT_13762
); break;
6110 case 13763: return ((char *) HT_13763
); break;
6111 case 13800: return ((char *) HT_13800
); break;
6114 return ((char *) "Unknown");
6117 char *strstatus (const uint devices_status
)
6119 switch (devices_status
)
6121 case STATUS_INIT
: return ((char *) ST_0000
); break;
6122 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6123 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6124 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6125 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6126 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6127 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6128 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6129 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6130 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6131 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6134 return ((char *) "Unknown");
6137 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6139 uint hash_type
= data
.hash_type
;
6140 uint hash_mode
= data
.hash_mode
;
6141 uint salt_type
= data
.salt_type
;
6142 uint opts_type
= data
.opts_type
;
6143 uint opti_type
= data
.opti_type
;
6144 uint dgst_size
= data
.dgst_size
;
6146 char *hashfile
= data
.hashfile
;
6150 uint digest_buf
[64] = { 0 };
6152 u64
*digest_buf64
= (u64
*) digest_buf
;
6154 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6156 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6158 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6164 case HASH_TYPE_DESCRYPT
:
6165 FP (digest_buf
[1], digest_buf
[0], tt
);
6168 case HASH_TYPE_DESRACF
:
6169 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6170 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6172 FP (digest_buf
[1], digest_buf
[0], tt
);
6176 FP (digest_buf
[1], digest_buf
[0], tt
);
6179 case HASH_TYPE_NETNTLM
:
6180 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6181 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6182 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6183 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6185 FP (digest_buf
[1], digest_buf
[0], tt
);
6186 FP (digest_buf
[3], digest_buf
[2], tt
);
6189 case HASH_TYPE_BSDICRYPT
:
6190 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6191 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6193 FP (digest_buf
[1], digest_buf
[0], tt
);
6198 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6203 digest_buf
[0] += MD4M_A
;
6204 digest_buf
[1] += MD4M_B
;
6205 digest_buf
[2] += MD4M_C
;
6206 digest_buf
[3] += MD4M_D
;
6210 digest_buf
[0] += MD5M_A
;
6211 digest_buf
[1] += MD5M_B
;
6212 digest_buf
[2] += MD5M_C
;
6213 digest_buf
[3] += MD5M_D
;
6216 case HASH_TYPE_SHA1
:
6217 digest_buf
[0] += SHA1M_A
;
6218 digest_buf
[1] += SHA1M_B
;
6219 digest_buf
[2] += SHA1M_C
;
6220 digest_buf
[3] += SHA1M_D
;
6221 digest_buf
[4] += SHA1M_E
;
6224 case HASH_TYPE_SHA256
:
6225 digest_buf
[0] += SHA256M_A
;
6226 digest_buf
[1] += SHA256M_B
;
6227 digest_buf
[2] += SHA256M_C
;
6228 digest_buf
[3] += SHA256M_D
;
6229 digest_buf
[4] += SHA256M_E
;
6230 digest_buf
[5] += SHA256M_F
;
6231 digest_buf
[6] += SHA256M_G
;
6232 digest_buf
[7] += SHA256M_H
;
6235 case HASH_TYPE_SHA384
:
6236 digest_buf64
[0] += SHA384M_A
;
6237 digest_buf64
[1] += SHA384M_B
;
6238 digest_buf64
[2] += SHA384M_C
;
6239 digest_buf64
[3] += SHA384M_D
;
6240 digest_buf64
[4] += SHA384M_E
;
6241 digest_buf64
[5] += SHA384M_F
;
6242 digest_buf64
[6] += 0;
6243 digest_buf64
[7] += 0;
6246 case HASH_TYPE_SHA512
:
6247 digest_buf64
[0] += SHA512M_A
;
6248 digest_buf64
[1] += SHA512M_B
;
6249 digest_buf64
[2] += SHA512M_C
;
6250 digest_buf64
[3] += SHA512M_D
;
6251 digest_buf64
[4] += SHA512M_E
;
6252 digest_buf64
[5] += SHA512M_F
;
6253 digest_buf64
[6] += SHA512M_G
;
6254 digest_buf64
[7] += SHA512M_H
;
6259 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6261 if (dgst_size
== DGST_SIZE_4_2
)
6263 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6265 else if (dgst_size
== DGST_SIZE_4_4
)
6267 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6269 else if (dgst_size
== DGST_SIZE_4_5
)
6271 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6273 else if (dgst_size
== DGST_SIZE_4_6
)
6275 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6277 else if (dgst_size
== DGST_SIZE_4_8
)
6279 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6281 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6283 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6285 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6287 else if (hash_type
== HASH_TYPE_SHA384
)
6289 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6291 else if (hash_type
== HASH_TYPE_SHA512
)
6293 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6295 else if (hash_type
== HASH_TYPE_GOST
)
6297 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6300 else if (dgst_size
== DGST_SIZE_4_64
)
6302 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6304 else if (dgst_size
== DGST_SIZE_8_25
)
6306 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6310 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6311 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6312 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6318 memset (&salt
, 0, sizeof (salt_t
));
6320 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6322 char *ptr
= (char *) salt
.salt_buf
;
6324 uint len
= salt
.salt_len
;
6326 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6332 case HASH_TYPE_NETNTLM
:
6334 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6335 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6337 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6343 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6345 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6353 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6355 uint max
= salt
.salt_len
/ 4;
6359 for (uint i
= 0; i
< max
; i
++)
6361 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6365 if (opts_type
& OPTS_TYPE_ST_HEX
)
6367 char tmp
[64] = { 0 };
6369 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6371 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6376 memcpy (ptr
, tmp
, len
);
6379 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6381 memset (ptr
+ len
, 0, memset_size
);
6383 salt
.salt_len
= len
;
6387 // some modes require special encoding
6390 uint out_buf_plain
[256] = { 0 };
6391 uint out_buf_salt
[256] = { 0 };
6393 char tmp_buf
[1024] = { 0 };
6395 char *ptr_plain
= (char *) out_buf_plain
;
6396 char *ptr_salt
= (char *) out_buf_salt
;
6398 if (hash_mode
== 22)
6400 char username
[30] = { 0 };
6402 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6404 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6406 u16
*ptr
= (u16
*) digest_buf
;
6408 tmp_buf
[ 0] = sig
[0];
6409 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6410 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6411 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6412 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6413 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6414 tmp_buf
[ 6] = sig
[1];
6415 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6416 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6417 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6418 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6419 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6420 tmp_buf
[12] = sig
[2];
6421 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6422 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6423 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6424 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6425 tmp_buf
[17] = sig
[3];
6426 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6427 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6428 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6429 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6430 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6431 tmp_buf
[23] = sig
[4];
6432 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6433 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6434 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6435 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6436 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6437 tmp_buf
[29] = sig
[5];
6439 snprintf (out_buf
, len
-1, "%s:%s",
6443 else if (hash_mode
== 23)
6445 // do not show the skyper part in output
6447 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6449 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6451 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6458 else if (hash_mode
== 101)
6460 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6462 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6463 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6464 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6465 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6466 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6468 memcpy (tmp_buf
, digest_buf
, 20);
6470 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6472 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6474 else if (hash_mode
== 111)
6476 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6478 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6479 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6480 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6481 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6482 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6484 memcpy (tmp_buf
, digest_buf
, 20);
6485 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6487 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6489 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6491 else if ((hash_mode
== 122) || (hash_mode
== 125))
6493 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6494 (char *) salt
.salt_buf
,
6501 else if (hash_mode
== 124)
6503 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6504 (char *) salt
.salt_buf
,
6511 else if (hash_mode
== 131)
6513 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6514 (char *) salt
.salt_buf
,
6522 else if (hash_mode
== 132)
6524 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6525 (char *) salt
.salt_buf
,
6532 else if (hash_mode
== 133)
6534 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6536 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6537 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6538 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6539 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6540 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6542 memcpy (tmp_buf
, digest_buf
, 20);
6544 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6546 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6548 else if (hash_mode
== 141)
6550 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6552 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6554 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6556 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6558 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6559 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6560 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6561 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6562 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6564 memcpy (tmp_buf
, digest_buf
, 20);
6566 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6570 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6572 else if (hash_mode
== 400)
6574 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6576 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6577 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6578 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6579 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6581 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6583 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6585 else if (hash_mode
== 500)
6587 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6589 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6590 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6591 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6592 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6594 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6596 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6598 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6602 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6605 else if (hash_mode
== 501)
6607 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6609 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6610 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6612 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6614 else if (hash_mode
== 1421)
6616 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6618 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6634 else if (hash_mode
== 1441)
6636 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6638 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6640 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6642 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6644 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6645 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6646 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6647 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6648 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6649 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6650 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6651 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6653 memcpy (tmp_buf
, digest_buf
, 32);
6655 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6659 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6661 else if (hash_mode
== 1500)
6663 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6664 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6665 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6666 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6667 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6669 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6671 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6673 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6674 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6676 memcpy (tmp_buf
, digest_buf
, 8);
6678 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6680 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6684 else if (hash_mode
== 1600)
6686 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6688 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6689 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6690 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6691 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6693 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6695 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6697 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6701 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6704 else if (hash_mode
== 1711)
6706 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6708 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6709 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6710 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6711 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6712 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6713 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6714 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6715 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6717 memcpy (tmp_buf
, digest_buf
, 64);
6718 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6720 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6722 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6724 else if (hash_mode
== 1722)
6726 uint
*ptr
= digest_buf
;
6728 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6729 (unsigned char *) salt
.salt_buf
,
6739 else if (hash_mode
== 1731)
6741 uint
*ptr
= digest_buf
;
6743 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6744 (unsigned char *) salt
.salt_buf
,
6754 else if (hash_mode
== 1800)
6758 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6759 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6760 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6761 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6762 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6763 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6764 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6765 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6767 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6769 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6771 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6775 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6778 else if (hash_mode
== 2100)
6782 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6784 salt
.salt_iter
+ 1);
6786 uint signature_len
= strlen (out_buf
);
6788 pos
+= signature_len
;
6789 len
-= signature_len
;
6791 char *salt_ptr
= (char *) salt
.salt_buf
;
6793 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6795 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6796 byte_swap_32 (digest_buf
[0]),
6797 byte_swap_32 (digest_buf
[1]),
6798 byte_swap_32 (digest_buf
[2]),
6799 byte_swap_32 (digest_buf
[3]));
6801 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6803 memcpy (tmp_buf
, digest_buf
, 16);
6805 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6807 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6808 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6809 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6810 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6812 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6813 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6814 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6815 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6817 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6818 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6819 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6820 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6822 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6823 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6824 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6825 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6827 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6828 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6829 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6830 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6834 else if (hash_mode
== 2500)
6836 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6838 wpa_t
*wpa
= &wpas
[salt_pos
];
6840 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6841 (char *) salt
.salt_buf
,
6855 else if (hash_mode
== 4400)
6857 snprintf (out_buf
, len
-1, "%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]));
6863 else if (hash_mode
== 4700)
6865 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6866 byte_swap_32 (digest_buf
[0]),
6867 byte_swap_32 (digest_buf
[1]),
6868 byte_swap_32 (digest_buf
[2]),
6869 byte_swap_32 (digest_buf
[3]),
6870 byte_swap_32 (digest_buf
[4]));
6872 else if (hash_mode
== 4800)
6874 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6876 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6881 byte_swap_32 (salt
.salt_buf
[0]),
6882 byte_swap_32 (salt
.salt_buf
[1]),
6883 byte_swap_32 (salt
.salt_buf
[2]),
6884 byte_swap_32 (salt
.salt_buf
[3]),
6887 else if (hash_mode
== 4900)
6889 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6890 byte_swap_32 (digest_buf
[0]),
6891 byte_swap_32 (digest_buf
[1]),
6892 byte_swap_32 (digest_buf
[2]),
6893 byte_swap_32 (digest_buf
[3]),
6894 byte_swap_32 (digest_buf
[4]));
6896 else if (hash_mode
== 5100)
6898 snprintf (out_buf
, len
-1, "%08x%08x",
6902 else if (hash_mode
== 5200)
6904 snprintf (out_buf
, len
-1, "%s", hashfile
);
6906 else if (hash_mode
== 5300)
6908 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6910 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6912 int buf_len
= len
-1;
6916 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6918 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6920 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6922 snprintf (out_buf
, buf_len
, ":");
6928 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6936 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6938 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6940 if ((i
== 0) || (i
== 5))
6942 snprintf (out_buf
, buf_len
, ":");
6948 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6956 for (uint i
= 0; i
< 4; i
++)
6960 snprintf (out_buf
, buf_len
, ":");
6966 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6972 else if (hash_mode
== 5400)
6974 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6976 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6978 int buf_len
= len
-1;
6982 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6984 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6986 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6988 snprintf (out_buf
, buf_len
, ":");
6994 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7002 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7004 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7006 if ((i
== 0) || (i
== 5))
7008 snprintf (out_buf
, buf_len
, ":");
7014 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7022 for (uint i
= 0; i
< 5; i
++)
7026 snprintf (out_buf
, buf_len
, ":");
7032 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7038 else if (hash_mode
== 5500)
7040 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7042 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7044 char user_buf
[64] = { 0 };
7045 char domain_buf
[64] = { 0 };
7046 char srvchall_buf
[1024] = { 0 };
7047 char clichall_buf
[1024] = { 0 };
7049 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7051 char *ptr
= (char *) netntlm
->userdomain_buf
;
7053 user_buf
[i
] = ptr
[j
];
7056 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7058 char *ptr
= (char *) netntlm
->userdomain_buf
;
7060 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7063 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7065 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7067 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7070 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7072 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7074 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7077 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7085 byte_swap_32 (salt
.salt_buf_pc
[0]),
7086 byte_swap_32 (salt
.salt_buf_pc
[1]),
7089 else if (hash_mode
== 5600)
7091 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7093 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7095 char user_buf
[64] = { 0 };
7096 char domain_buf
[64] = { 0 };
7097 char srvchall_buf
[1024] = { 0 };
7098 char clichall_buf
[1024] = { 0 };
7100 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7102 char *ptr
= (char *) netntlm
->userdomain_buf
;
7104 user_buf
[i
] = ptr
[j
];
7107 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7109 char *ptr
= (char *) netntlm
->userdomain_buf
;
7111 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7114 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7116 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7118 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7121 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7123 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7125 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7128 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7138 else if (hash_mode
== 5700)
7140 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7142 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7143 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7144 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7145 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7146 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7147 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7148 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7149 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7151 memcpy (tmp_buf
, digest_buf
, 32);
7153 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7157 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7159 else if (hash_mode
== 5800)
7161 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7162 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7163 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7164 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7165 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7167 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7174 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7176 snprintf (out_buf
, len
-1, "%s", hashfile
);
7178 else if (hash_mode
== 6300)
7180 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7182 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7183 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7184 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7185 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7187 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7189 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7191 else if (hash_mode
== 6400)
7193 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7195 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7197 else if (hash_mode
== 6500)
7199 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7201 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7203 else if (hash_mode
== 6600)
7205 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7207 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7209 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7210 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7212 uint buf_len
= len
- 1;
7214 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7217 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7219 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7224 else if (hash_mode
== 6700)
7226 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7228 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7230 else if (hash_mode
== 6800)
7232 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7234 else if (hash_mode
== 7100)
7236 uint
*ptr
= digest_buf
;
7238 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7240 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7242 uint esalt
[8] = { 0 };
7244 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7245 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7246 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7247 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7248 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7249 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7250 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7251 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7253 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",
7254 SIGNATURE_SHA512OSX
,
7256 esalt
[ 0], esalt
[ 1],
7257 esalt
[ 2], esalt
[ 3],
7258 esalt
[ 4], esalt
[ 5],
7259 esalt
[ 6], esalt
[ 7],
7267 ptr
[15], ptr
[14]);
7269 else if (hash_mode
== 7200)
7271 uint
*ptr
= digest_buf
;
7273 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7275 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7279 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7281 len_used
= strlen (out_buf
);
7283 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7285 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7287 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7290 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",
7298 ptr
[15], ptr
[14]);
7300 else if (hash_mode
== 7300)
7302 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7304 rakp_t
*rakp
= &rakps
[salt_pos
];
7306 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7308 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7311 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7318 else if (hash_mode
== 7400)
7320 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7322 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7323 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7324 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7325 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7326 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7327 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7328 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7329 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7331 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7333 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7335 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7339 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7342 else if (hash_mode
== 7500)
7344 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7346 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7348 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7349 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7351 char data
[128] = { 0 };
7353 char *ptr_data
= data
;
7355 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7357 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7360 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7362 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7367 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7369 (char *) krb5pa
->user
,
7370 (char *) krb5pa
->realm
,
7371 (char *) krb5pa
->salt
,
7374 else if (hash_mode
== 7700)
7376 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7377 (char *) salt
.salt_buf
,
7381 else if (hash_mode
== 7800)
7383 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7384 (char *) salt
.salt_buf
,
7391 else if (hash_mode
== 7900)
7393 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7397 char *tmp
= (char *) salt
.salt_buf_pc
;
7399 ptr_plain
[42] = tmp
[0];
7405 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7407 else if (hash_mode
== 8000)
7409 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7410 (unsigned char *) salt
.salt_buf
,
7420 else if (hash_mode
== 8100)
7422 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7423 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7425 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7426 (unsigned char *) salt
.salt_buf
,
7433 else if (hash_mode
== 8200)
7435 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7437 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7439 char data_buf
[4096] = { 0 };
7441 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7443 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7446 data_buf
[cloudkey
->data_len
* 2] = 0;
7448 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7449 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7450 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7451 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7452 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7453 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7454 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7455 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7457 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7458 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7459 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7460 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7462 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7478 else if (hash_mode
== 8300)
7480 char digest_buf_c
[34] = { 0 };
7482 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7483 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7484 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7485 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7486 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7488 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7490 digest_buf_c
[32] = 0;
7494 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7496 char domain_buf_c
[33] = { 0 };
7498 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7500 for (uint i
= 0; i
< salt_pc_len
; i
++)
7502 const char next
= domain_buf_c
[i
];
7504 domain_buf_c
[i
] = '.';
7509 domain_buf_c
[salt_pc_len
] = 0;
7513 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7515 else if (hash_mode
== 8500)
7517 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7519 else if (hash_mode
== 2612)
7521 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7523 (char *) salt
.salt_buf
,
7529 else if (hash_mode
== 3711)
7531 char *salt_ptr
= (char *) salt
.salt_buf
;
7533 salt_ptr
[salt
.salt_len
- 1] = 0;
7535 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7536 SIGNATURE_MEDIAWIKI_B
,
7543 else if (hash_mode
== 8800)
7545 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7547 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7549 char tmp
[3073] = { 0 };
7551 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7553 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7558 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7559 SIGNATURE_ANDROIDFDE
,
7560 byte_swap_32 (salt
.salt_buf
[0]),
7561 byte_swap_32 (salt
.salt_buf
[1]),
7562 byte_swap_32 (salt
.salt_buf
[2]),
7563 byte_swap_32 (salt
.salt_buf
[3]),
7564 byte_swap_32 (digest_buf
[0]),
7565 byte_swap_32 (digest_buf
[1]),
7566 byte_swap_32 (digest_buf
[2]),
7567 byte_swap_32 (digest_buf
[3]),
7570 else if (hash_mode
== 8900)
7572 uint N
= salt
.scrypt_N
;
7573 uint r
= salt
.scrypt_r
;
7574 uint p
= salt
.scrypt_p
;
7576 char base64_salt
[32] = { 0 };
7578 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7580 memset (tmp_buf
, 0, 46);
7582 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7583 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7584 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7585 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7586 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7587 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7588 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7589 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7590 digest_buf
[8] = 0; // needed for base64_encode ()
7592 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7594 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7602 else if (hash_mode
== 9000)
7604 snprintf (out_buf
, len
-1, "%s", hashfile
);
7606 else if (hash_mode
== 9200)
7610 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7612 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7614 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7618 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7619 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7620 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7621 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7622 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7623 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7624 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7625 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7626 digest_buf
[8] = 0; // needed for base64_encode ()
7628 char tmp_buf
[64] = { 0 };
7630 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7631 tmp_buf
[43] = 0; // cut it here
7635 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7637 else if (hash_mode
== 9300)
7639 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7640 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7641 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7642 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7643 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7644 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7645 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7646 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7647 digest_buf
[8] = 0; // needed for base64_encode ()
7649 char tmp_buf
[64] = { 0 };
7651 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7652 tmp_buf
[43] = 0; // cut it here
7654 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7656 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7658 else if (hash_mode
== 9400)
7660 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7662 office2007_t
*office2007
= &office2007s
[salt_pos
];
7664 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7665 SIGNATURE_OFFICE2007
,
7668 office2007
->keySize
,
7674 office2007
->encryptedVerifier
[0],
7675 office2007
->encryptedVerifier
[1],
7676 office2007
->encryptedVerifier
[2],
7677 office2007
->encryptedVerifier
[3],
7678 office2007
->encryptedVerifierHash
[0],
7679 office2007
->encryptedVerifierHash
[1],
7680 office2007
->encryptedVerifierHash
[2],
7681 office2007
->encryptedVerifierHash
[3],
7682 office2007
->encryptedVerifierHash
[4]);
7684 else if (hash_mode
== 9500)
7686 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7688 office2010_t
*office2010
= &office2010s
[salt_pos
];
7690 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,
7696 office2010
->encryptedVerifier
[0],
7697 office2010
->encryptedVerifier
[1],
7698 office2010
->encryptedVerifier
[2],
7699 office2010
->encryptedVerifier
[3],
7700 office2010
->encryptedVerifierHash
[0],
7701 office2010
->encryptedVerifierHash
[1],
7702 office2010
->encryptedVerifierHash
[2],
7703 office2010
->encryptedVerifierHash
[3],
7704 office2010
->encryptedVerifierHash
[4],
7705 office2010
->encryptedVerifierHash
[5],
7706 office2010
->encryptedVerifierHash
[6],
7707 office2010
->encryptedVerifierHash
[7]);
7709 else if (hash_mode
== 9600)
7711 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7713 office2013_t
*office2013
= &office2013s
[salt_pos
];
7715 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,
7721 office2013
->encryptedVerifier
[0],
7722 office2013
->encryptedVerifier
[1],
7723 office2013
->encryptedVerifier
[2],
7724 office2013
->encryptedVerifier
[3],
7725 office2013
->encryptedVerifierHash
[0],
7726 office2013
->encryptedVerifierHash
[1],
7727 office2013
->encryptedVerifierHash
[2],
7728 office2013
->encryptedVerifierHash
[3],
7729 office2013
->encryptedVerifierHash
[4],
7730 office2013
->encryptedVerifierHash
[5],
7731 office2013
->encryptedVerifierHash
[6],
7732 office2013
->encryptedVerifierHash
[7]);
7734 else if (hash_mode
== 9700)
7736 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7738 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7740 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7741 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7742 byte_swap_32 (salt
.salt_buf
[0]),
7743 byte_swap_32 (salt
.salt_buf
[1]),
7744 byte_swap_32 (salt
.salt_buf
[2]),
7745 byte_swap_32 (salt
.salt_buf
[3]),
7746 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7747 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7748 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7749 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7750 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7751 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7752 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7753 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7755 else if (hash_mode
== 9710)
7757 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7759 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7761 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7762 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7763 byte_swap_32 (salt
.salt_buf
[0]),
7764 byte_swap_32 (salt
.salt_buf
[1]),
7765 byte_swap_32 (salt
.salt_buf
[2]),
7766 byte_swap_32 (salt
.salt_buf
[3]),
7767 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7768 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7769 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7770 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7771 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7772 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7773 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7774 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7776 else if (hash_mode
== 9720)
7778 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7780 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7782 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7784 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7785 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7786 byte_swap_32 (salt
.salt_buf
[0]),
7787 byte_swap_32 (salt
.salt_buf
[1]),
7788 byte_swap_32 (salt
.salt_buf
[2]),
7789 byte_swap_32 (salt
.salt_buf
[3]),
7790 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7791 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7792 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7793 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7794 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7795 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7796 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7797 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7804 else if (hash_mode
== 9800)
7806 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7808 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7810 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7811 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7816 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7817 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7818 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7819 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7820 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7821 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7822 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7823 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7824 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7826 else if (hash_mode
== 9810)
7828 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7830 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7832 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7833 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7838 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7839 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7840 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7841 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7842 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7843 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7844 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7845 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7846 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7848 else if (hash_mode
== 9820)
7850 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7852 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7854 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7856 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7857 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7862 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7863 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7864 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7865 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7866 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7867 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7868 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7869 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7870 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7877 else if (hash_mode
== 10000)
7881 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7883 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7885 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7889 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7890 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7891 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7892 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7893 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7894 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7895 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7896 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7897 digest_buf
[8] = 0; // needed for base64_encode ()
7899 char tmp_buf
[64] = { 0 };
7901 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7905 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7907 else if (hash_mode
== 10100)
7909 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7914 byte_swap_32 (salt
.salt_buf
[0]),
7915 byte_swap_32 (salt
.salt_buf
[1]),
7916 byte_swap_32 (salt
.salt_buf
[2]),
7917 byte_swap_32 (salt
.salt_buf
[3]));
7919 else if (hash_mode
== 10200)
7921 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7923 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7927 char challenge
[100] = { 0 };
7929 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7933 char tmp_buf
[100] = { 0 };
7935 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7936 (char *) cram_md5
->user
,
7942 char response
[100] = { 0 };
7944 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7946 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7948 else if (hash_mode
== 10300)
7950 char tmp_buf
[100] = { 0 };
7952 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7953 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7955 uint tmp_len
= 20 + salt
.salt_len
;
7959 char base64_encoded
[100] = { 0 };
7961 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7963 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7965 else if (hash_mode
== 10400)
7967 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7969 pdf_t
*pdf
= &pdfs
[salt_pos
];
7971 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",
7979 byte_swap_32 (pdf
->id_buf
[0]),
7980 byte_swap_32 (pdf
->id_buf
[1]),
7981 byte_swap_32 (pdf
->id_buf
[2]),
7982 byte_swap_32 (pdf
->id_buf
[3]),
7984 byte_swap_32 (pdf
->u_buf
[0]),
7985 byte_swap_32 (pdf
->u_buf
[1]),
7986 byte_swap_32 (pdf
->u_buf
[2]),
7987 byte_swap_32 (pdf
->u_buf
[3]),
7988 byte_swap_32 (pdf
->u_buf
[4]),
7989 byte_swap_32 (pdf
->u_buf
[5]),
7990 byte_swap_32 (pdf
->u_buf
[6]),
7991 byte_swap_32 (pdf
->u_buf
[7]),
7993 byte_swap_32 (pdf
->o_buf
[0]),
7994 byte_swap_32 (pdf
->o_buf
[1]),
7995 byte_swap_32 (pdf
->o_buf
[2]),
7996 byte_swap_32 (pdf
->o_buf
[3]),
7997 byte_swap_32 (pdf
->o_buf
[4]),
7998 byte_swap_32 (pdf
->o_buf
[5]),
7999 byte_swap_32 (pdf
->o_buf
[6]),
8000 byte_swap_32 (pdf
->o_buf
[7])
8003 else if (hash_mode
== 10410)
8005 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8007 pdf_t
*pdf
= &pdfs
[salt_pos
];
8009 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",
8017 byte_swap_32 (pdf
->id_buf
[0]),
8018 byte_swap_32 (pdf
->id_buf
[1]),
8019 byte_swap_32 (pdf
->id_buf
[2]),
8020 byte_swap_32 (pdf
->id_buf
[3]),
8022 byte_swap_32 (pdf
->u_buf
[0]),
8023 byte_swap_32 (pdf
->u_buf
[1]),
8024 byte_swap_32 (pdf
->u_buf
[2]),
8025 byte_swap_32 (pdf
->u_buf
[3]),
8026 byte_swap_32 (pdf
->u_buf
[4]),
8027 byte_swap_32 (pdf
->u_buf
[5]),
8028 byte_swap_32 (pdf
->u_buf
[6]),
8029 byte_swap_32 (pdf
->u_buf
[7]),
8031 byte_swap_32 (pdf
->o_buf
[0]),
8032 byte_swap_32 (pdf
->o_buf
[1]),
8033 byte_swap_32 (pdf
->o_buf
[2]),
8034 byte_swap_32 (pdf
->o_buf
[3]),
8035 byte_swap_32 (pdf
->o_buf
[4]),
8036 byte_swap_32 (pdf
->o_buf
[5]),
8037 byte_swap_32 (pdf
->o_buf
[6]),
8038 byte_swap_32 (pdf
->o_buf
[7])
8041 else if (hash_mode
== 10420)
8043 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8045 pdf_t
*pdf
= &pdfs
[salt_pos
];
8047 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8049 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",
8057 byte_swap_32 (pdf
->id_buf
[0]),
8058 byte_swap_32 (pdf
->id_buf
[1]),
8059 byte_swap_32 (pdf
->id_buf
[2]),
8060 byte_swap_32 (pdf
->id_buf
[3]),
8062 byte_swap_32 (pdf
->u_buf
[0]),
8063 byte_swap_32 (pdf
->u_buf
[1]),
8064 byte_swap_32 (pdf
->u_buf
[2]),
8065 byte_swap_32 (pdf
->u_buf
[3]),
8066 byte_swap_32 (pdf
->u_buf
[4]),
8067 byte_swap_32 (pdf
->u_buf
[5]),
8068 byte_swap_32 (pdf
->u_buf
[6]),
8069 byte_swap_32 (pdf
->u_buf
[7]),
8071 byte_swap_32 (pdf
->o_buf
[0]),
8072 byte_swap_32 (pdf
->o_buf
[1]),
8073 byte_swap_32 (pdf
->o_buf
[2]),
8074 byte_swap_32 (pdf
->o_buf
[3]),
8075 byte_swap_32 (pdf
->o_buf
[4]),
8076 byte_swap_32 (pdf
->o_buf
[5]),
8077 byte_swap_32 (pdf
->o_buf
[6]),
8078 byte_swap_32 (pdf
->o_buf
[7]),
8086 else if (hash_mode
== 10500)
8088 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8090 pdf_t
*pdf
= &pdfs
[salt_pos
];
8092 if (pdf
->id_len
== 32)
8094 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",
8102 byte_swap_32 (pdf
->id_buf
[0]),
8103 byte_swap_32 (pdf
->id_buf
[1]),
8104 byte_swap_32 (pdf
->id_buf
[2]),
8105 byte_swap_32 (pdf
->id_buf
[3]),
8106 byte_swap_32 (pdf
->id_buf
[4]),
8107 byte_swap_32 (pdf
->id_buf
[5]),
8108 byte_swap_32 (pdf
->id_buf
[6]),
8109 byte_swap_32 (pdf
->id_buf
[7]),
8111 byte_swap_32 (pdf
->u_buf
[0]),
8112 byte_swap_32 (pdf
->u_buf
[1]),
8113 byte_swap_32 (pdf
->u_buf
[2]),
8114 byte_swap_32 (pdf
->u_buf
[3]),
8115 byte_swap_32 (pdf
->u_buf
[4]),
8116 byte_swap_32 (pdf
->u_buf
[5]),
8117 byte_swap_32 (pdf
->u_buf
[6]),
8118 byte_swap_32 (pdf
->u_buf
[7]),
8120 byte_swap_32 (pdf
->o_buf
[0]),
8121 byte_swap_32 (pdf
->o_buf
[1]),
8122 byte_swap_32 (pdf
->o_buf
[2]),
8123 byte_swap_32 (pdf
->o_buf
[3]),
8124 byte_swap_32 (pdf
->o_buf
[4]),
8125 byte_swap_32 (pdf
->o_buf
[5]),
8126 byte_swap_32 (pdf
->o_buf
[6]),
8127 byte_swap_32 (pdf
->o_buf
[7])
8132 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",
8140 byte_swap_32 (pdf
->id_buf
[0]),
8141 byte_swap_32 (pdf
->id_buf
[1]),
8142 byte_swap_32 (pdf
->id_buf
[2]),
8143 byte_swap_32 (pdf
->id_buf
[3]),
8145 byte_swap_32 (pdf
->u_buf
[0]),
8146 byte_swap_32 (pdf
->u_buf
[1]),
8147 byte_swap_32 (pdf
->u_buf
[2]),
8148 byte_swap_32 (pdf
->u_buf
[3]),
8149 byte_swap_32 (pdf
->u_buf
[4]),
8150 byte_swap_32 (pdf
->u_buf
[5]),
8151 byte_swap_32 (pdf
->u_buf
[6]),
8152 byte_swap_32 (pdf
->u_buf
[7]),
8154 byte_swap_32 (pdf
->o_buf
[0]),
8155 byte_swap_32 (pdf
->o_buf
[1]),
8156 byte_swap_32 (pdf
->o_buf
[2]),
8157 byte_swap_32 (pdf
->o_buf
[3]),
8158 byte_swap_32 (pdf
->o_buf
[4]),
8159 byte_swap_32 (pdf
->o_buf
[5]),
8160 byte_swap_32 (pdf
->o_buf
[6]),
8161 byte_swap_32 (pdf
->o_buf
[7])
8165 else if (hash_mode
== 10600)
8167 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8169 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8170 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8172 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8174 else if (hash_mode
== 10700)
8176 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8178 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8179 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8181 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8183 else if (hash_mode
== 10900)
8185 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8187 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8188 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8190 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8192 else if (hash_mode
== 11100)
8194 u32 salt_challenge
= salt
.salt_buf
[0];
8196 salt_challenge
= byte_swap_32 (salt_challenge
);
8198 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8200 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8201 SIGNATURE_POSTGRESQL_AUTH
,
8209 else if (hash_mode
== 11200)
8211 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8212 SIGNATURE_MYSQL_AUTH
,
8213 (unsigned char *) salt
.salt_buf
,
8220 else if (hash_mode
== 11300)
8222 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8224 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8226 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8227 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8228 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8230 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8231 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8232 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8234 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8236 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8238 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8241 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8243 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8245 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8248 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8250 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8252 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8255 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8256 SIGNATURE_BITCOIN_WALLET
,
8260 (unsigned char *) salt
.salt_buf
,
8268 free (cry_master_buf
);
8270 free (public_key_buf
);
8272 else if (hash_mode
== 11400)
8274 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8276 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8277 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8279 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8281 else if (hash_mode
== 11600)
8283 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8285 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8287 const uint data_len
= seven_zip
->data_len
;
8289 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8291 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8293 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8295 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8298 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8299 SIGNATURE_SEVEN_ZIP
,
8303 (char *) seven_zip
->salt_buf
,
8305 seven_zip
->iv_buf
[0],
8306 seven_zip
->iv_buf
[1],
8307 seven_zip
->iv_buf
[2],
8308 seven_zip
->iv_buf
[3],
8310 seven_zip
->data_len
,
8311 seven_zip
->unpack_size
,
8316 else if (hash_mode
== 11700)
8318 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8328 else if (hash_mode
== 11800)
8330 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8348 else if (hash_mode
== 11900)
8350 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8352 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8353 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8355 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8357 else if (hash_mode
== 12000)
8359 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8361 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8362 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8364 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8366 else if (hash_mode
== 12100)
8368 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8370 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8371 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8373 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8375 else if (hash_mode
== 12200)
8377 uint
*ptr_digest
= digest_buf
;
8378 uint
*ptr_salt
= salt
.salt_buf
;
8380 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8387 else if (hash_mode
== 12300)
8389 uint
*ptr_digest
= digest_buf
;
8390 uint
*ptr_salt
= salt
.salt_buf
;
8392 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",
8393 ptr_digest
[ 0], ptr_digest
[ 1],
8394 ptr_digest
[ 2], ptr_digest
[ 3],
8395 ptr_digest
[ 4], ptr_digest
[ 5],
8396 ptr_digest
[ 6], ptr_digest
[ 7],
8397 ptr_digest
[ 8], ptr_digest
[ 9],
8398 ptr_digest
[10], ptr_digest
[11],
8399 ptr_digest
[12], ptr_digest
[13],
8400 ptr_digest
[14], ptr_digest
[15],
8406 else if (hash_mode
== 12400)
8408 // encode iteration count
8410 char salt_iter
[5] = { 0 };
8412 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8413 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8414 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8415 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8420 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8421 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8422 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8423 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8428 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8430 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8431 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8433 memcpy (tmp_buf
, digest_buf
, 8);
8435 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8439 // fill the resulting buffer
8441 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8443 else if (hash_mode
== 12500)
8445 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8447 byte_swap_32 (salt
.salt_buf
[0]),
8448 byte_swap_32 (salt
.salt_buf
[1]),
8454 else if (hash_mode
== 12600)
8456 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8457 digest_buf
[0] + salt
.salt_buf_pc
[0],
8458 digest_buf
[1] + salt
.salt_buf_pc
[1],
8459 digest_buf
[2] + salt
.salt_buf_pc
[2],
8460 digest_buf
[3] + salt
.salt_buf_pc
[3],
8461 digest_buf
[4] + salt
.salt_buf_pc
[4],
8462 digest_buf
[5] + salt
.salt_buf_pc
[5],
8463 digest_buf
[6] + salt
.salt_buf_pc
[6],
8464 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8466 else if (hash_mode
== 12700)
8468 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8470 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8471 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8473 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8475 else if (hash_mode
== 12800)
8477 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8479 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",
8492 byte_swap_32 (digest_buf
[0]),
8493 byte_swap_32 (digest_buf
[1]),
8494 byte_swap_32 (digest_buf
[2]),
8495 byte_swap_32 (digest_buf
[3]),
8496 byte_swap_32 (digest_buf
[4]),
8497 byte_swap_32 (digest_buf
[5]),
8498 byte_swap_32 (digest_buf
[6]),
8499 byte_swap_32 (digest_buf
[7])
8502 else if (hash_mode
== 12900)
8504 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",
8513 byte_swap_32 (digest_buf
[0]),
8514 byte_swap_32 (digest_buf
[1]),
8515 byte_swap_32 (digest_buf
[2]),
8516 byte_swap_32 (digest_buf
[3]),
8517 byte_swap_32 (digest_buf
[4]),
8518 byte_swap_32 (digest_buf
[5]),
8519 byte_swap_32 (digest_buf
[6]),
8520 byte_swap_32 (digest_buf
[7]),
8527 else if (hash_mode
== 13000)
8529 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8531 rar5_t
*rar5
= &rar5s
[salt_pos
];
8533 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8543 byte_swap_32 (digest_buf
[0]),
8544 byte_swap_32 (digest_buf
[1])
8547 else if (hash_mode
== 13100)
8549 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8551 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8553 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8554 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8556 char data
[2560 * 4 * 2] = { 0 };
8558 char *ptr_data
= data
;
8560 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8561 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8566 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8567 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8569 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8571 (char *) krb5tgs
->account_info
,
8575 else if (hash_mode
== 13200)
8577 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8591 else if (hash_mode
== 13300)
8593 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8594 SIGNATURE_AXCRYPT_SHA1
,
8600 else if (hash_mode
== 13400)
8602 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8604 keepass_t
*keepass
= &keepasss
[salt_pos
];
8606 u32 version
= (u32
) keepass
->version
;
8607 u32 rounds
= salt
.salt_iter
;
8608 u32 algorithm
= (u32
) keepass
->algorithm
;
8609 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8611 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8612 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8613 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8614 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8615 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8617 /* specific to version 1 */
8621 /* specific to version 2 */
8622 u32 expected_bytes_len
;
8623 u32
*ptr_expected_bytes
;
8625 u32 final_random_seed_len
;
8626 u32 transf_random_seed_len
;
8628 u32 contents_hash_len
;
8630 transf_random_seed_len
= 8;
8632 contents_hash_len
= 8;
8633 final_random_seed_len
= 8;
8636 final_random_seed_len
= 4;
8638 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8644 char *ptr_data
= out_buf
;
8646 ptr_data
+= strlen(out_buf
);
8651 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8652 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8657 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8658 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8663 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8664 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8671 contents_len
= (u32
) keepass
->contents_len
;
8672 ptr_contents
= (u32
*) keepass
->contents
;
8674 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8675 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8687 char ptr_contents_len
[10] = { 0 };
8689 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8691 sprintf (ptr_data
, "%d", contents_len
);
8693 ptr_data
+= strlen(ptr_contents_len
);
8698 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8699 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8701 else if (version
== 2)
8703 expected_bytes_len
= 8;
8704 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8706 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8707 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8712 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8713 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8727 sprintf (ptr_data
, "%d", keyfile_len
);
8734 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8735 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8738 else if (hash_mode
== 13500)
8740 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8742 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8744 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8746 char pstoken_tmp
[1024 + 1] = { 0 };
8748 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8750 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8752 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8755 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8763 else if (hash_mode
== 13600)
8765 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8767 zip2_t
*zip2
= &zip2s
[salt_pos
];
8769 const u32 salt_len
= zip2
->salt_len
;
8771 char salt_tmp
[32 + 1] = { 0 };
8773 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8775 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8777 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8780 const u32 data_len
= zip2
->data_len
;
8782 char data_tmp
[8192 + 1] = { 0 };
8784 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8786 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8788 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8791 const u32 auth_len
= zip2
->auth_len
;
8793 char auth_tmp
[20 + 1] = { 0 };
8795 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8797 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8799 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8802 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8803 SIGNATURE_ZIP2_START
,
8809 zip2
->compress_length
,
8812 SIGNATURE_ZIP2_STOP
);
8814 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8816 snprintf (out_buf
, len
-1, "%s", hashfile
);
8818 else if (hash_mode
== 13800)
8820 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8822 win8phone_t
*esalt
= &esalts
[salt_pos
];
8824 char buf
[256 + 1] = { 0 };
8826 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8828 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8831 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8844 if (hash_type
== HASH_TYPE_MD4
)
8846 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8852 else if (hash_type
== HASH_TYPE_MD5
)
8854 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8860 else if (hash_type
== HASH_TYPE_SHA1
)
8862 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8869 else if (hash_type
== HASH_TYPE_SHA256
)
8871 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8881 else if (hash_type
== HASH_TYPE_SHA384
)
8883 uint
*ptr
= digest_buf
;
8885 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8893 else if (hash_type
== HASH_TYPE_SHA512
)
8895 uint
*ptr
= digest_buf
;
8897 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8907 else if (hash_type
== HASH_TYPE_LM
)
8909 snprintf (out_buf
, len
-1, "%08x%08x",
8913 else if (hash_type
== HASH_TYPE_ORACLEH
)
8915 snprintf (out_buf
, len
-1, "%08X%08X",
8919 else if (hash_type
== HASH_TYPE_BCRYPT
)
8921 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8922 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8924 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8926 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8928 else if (hash_type
== HASH_TYPE_KECCAK
)
8930 uint
*ptr
= digest_buf
;
8932 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",
8960 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8962 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8964 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8971 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8973 digest_buf
[ 0] = digest_buf
[ 0];
8974 digest_buf
[ 1] = digest_buf
[ 1];
8975 digest_buf
[ 2] = digest_buf
[ 2];
8976 digest_buf
[ 3] = digest_buf
[ 3];
8977 digest_buf
[ 4] = digest_buf
[ 4];
8978 digest_buf
[ 5] = digest_buf
[ 5];
8979 digest_buf
[ 6] = digest_buf
[ 6];
8980 digest_buf
[ 7] = digest_buf
[ 7];
8981 digest_buf
[ 8] = digest_buf
[ 8];
8982 digest_buf
[ 9] = digest_buf
[ 9];
8983 digest_buf
[10] = digest_buf
[10];
8984 digest_buf
[11] = digest_buf
[11];
8985 digest_buf
[12] = digest_buf
[12];
8986 digest_buf
[13] = digest_buf
[13];
8987 digest_buf
[14] = digest_buf
[14];
8988 digest_buf
[15] = digest_buf
[15];
8990 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9008 else if (hash_type
== HASH_TYPE_GOST
)
9010 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9020 else if (hash_type
== HASH_TYPE_MYSQL
)
9022 snprintf (out_buf
, len
-1, "%08x%08x",
9026 else if (hash_type
== HASH_TYPE_LOTUS5
)
9028 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9034 else if (hash_type
== HASH_TYPE_LOTUS6
)
9036 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9037 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9038 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9039 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9041 char buf
[16] = { 0 };
9043 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9044 memcpy (buf
+ 5, digest_buf
, 9);
9048 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9050 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9053 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9055 else if (hash_type
== HASH_TYPE_LOTUS8
)
9057 char buf
[52] = { 0 };
9061 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9067 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9071 buf
[26] = salt
.salt_buf_pc
[0];
9072 buf
[27] = salt
.salt_buf_pc
[1];
9076 memcpy (buf
+ 28, digest_buf
, 8);
9078 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9082 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9084 else if (hash_type
== HASH_TYPE_CRC32
)
9086 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9090 if (salt_type
== SALT_TYPE_INTERN
)
9092 size_t pos
= strlen (out_buf
);
9094 out_buf
[pos
] = data
.separator
;
9096 char *ptr
= (char *) salt
.salt_buf
;
9098 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9100 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9104 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9106 memset (hccap
, 0, sizeof (hccap_t
));
9108 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9110 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9112 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9113 wpa_t
*wpa
= &wpas
[salt_pos
];
9115 hccap
->keyver
= wpa
->keyver
;
9117 hccap
->eapol_size
= wpa
->eapol_size
;
9119 if (wpa
->keyver
!= 1)
9121 uint eapol_tmp
[64] = { 0 };
9123 for (uint i
= 0; i
< 64; i
++)
9125 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9128 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9132 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9135 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9136 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9137 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9138 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9140 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9142 uint dgst_size
= data
.dgst_size
;
9144 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9146 if (wpa
->keyver
!= 1)
9148 uint digest_tmp
[4] = { 0 };
9150 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9151 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9152 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9153 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9155 memcpy (hccap
->keymic
, digest_tmp
, 16);
9159 memcpy (hccap
->keymic
, digest_ptr
, 16);
9163 void SuspendThreads ()
9165 if (data
.devices_status
!= STATUS_RUNNING
) return;
9167 hc_timer_set (&data
.timer_paused
);
9169 data
.devices_status
= STATUS_PAUSED
;
9171 log_info ("Paused");
9174 void ResumeThreads ()
9176 if (data
.devices_status
!= STATUS_PAUSED
) return;
9180 hc_timer_get (data
.timer_paused
, ms_paused
);
9182 data
.ms_paused
+= ms_paused
;
9184 data
.devices_status
= STATUS_RUNNING
;
9186 log_info ("Resumed");
9191 data
.devices_status
= STATUS_BYPASS
;
9193 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9196 void stop_at_checkpoint ()
9198 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9200 if (data
.devices_status
!= STATUS_RUNNING
) return;
9203 // this feature only makes sense if --restore-disable was not specified
9205 if (data
.restore_disable
== 1)
9207 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9212 // check if monitoring of Restore Point updates should be enabled or disabled
9214 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9216 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9218 // save the current restore point value
9220 data
.checkpoint_cur_words
= get_lowest_words_done ();
9222 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9226 data
.devices_status
= STATUS_RUNNING
;
9228 // reset the global value for checkpoint checks
9230 data
.checkpoint_cur_words
= 0;
9232 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9238 data
.devices_status
= STATUS_ABORTED
;
9243 data
.devices_status
= STATUS_QUIT
;
9246 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9248 const size_t len
= strlen (s
);
9250 for (size_t in
= 0; in
< len
; in
++)
9256 s
[in
] = replace_char
;
9261 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9263 char s_escaped
[1024] = { 0 };
9265 size_t s_escaped_max
= sizeof (s_escaped
);
9267 const size_t len
= strlen (s
);
9269 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9275 s_escaped
[out
] = escape_char
;
9280 if (out
== s_escaped_max
- 2) break;
9285 strncpy (s
, s_escaped
, s_max
- 1);
9288 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9290 FILE *fp
= fopen (kernel_file
, "rb");
9296 memset (&st
, 0, sizeof (st
));
9298 stat (kernel_file
, &st
);
9300 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9302 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9304 if (num_read
!= (size_t) st
.st_size
)
9306 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9313 buf
[st
.st_size
] = 0;
9315 for (int i
= 0; i
< num_devices
; i
++)
9317 kernel_lengths
[i
] = (size_t) st
.st_size
;
9319 kernel_sources
[i
] = buf
;
9324 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9332 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9334 if (binary_size
> 0)
9336 FILE *fp
= fopen (dst
, "wb");
9339 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9350 restore_data_t
*init_restore (int argc
, char **argv
)
9352 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9354 if (data
.restore_disable
== 0)
9356 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9360 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9364 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9373 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9375 int pidbin_len
= -1;
9378 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9380 FILE *fd
= fopen (pidbin
, "rb");
9384 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9386 pidbin
[pidbin_len
] = 0;
9390 char *argv0_r
= strrchr (argv
[0], '/');
9392 char *pidbin_r
= strrchr (pidbin
, '/');
9394 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9396 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9398 if (strcmp (argv0_r
, pidbin_r
) == 0)
9400 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9407 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9409 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9411 int pidbin2_len
= -1;
9413 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9414 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9416 pidbin
[pidbin_len
] = 0;
9417 pidbin2
[pidbin2_len
] = 0;
9421 if (strcmp (pidbin
, pidbin2
) == 0)
9423 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9436 if (rd
->version_bin
< RESTORE_MIN
)
9438 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9445 memset (rd
, 0, sizeof (restore_data_t
));
9447 rd
->version_bin
= VERSION_BIN
;
9450 rd
->pid
= getpid ();
9452 rd
->pid
= GetCurrentProcessId ();
9455 if (getcwd (rd
->cwd
, 255) == NULL
)
9468 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9470 FILE *fp
= fopen (eff_restore_file
, "rb");
9474 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9479 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9481 log_error ("ERROR: Can't read %s", eff_restore_file
);
9486 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9488 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9490 for (uint i
= 0; i
< rd
->argc
; i
++)
9492 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9494 log_error ("ERROR: Can't read %s", eff_restore_file
);
9499 size_t len
= strlen (buf
);
9501 if (len
) buf
[len
- 1] = 0;
9503 rd
->argv
[i
] = mystrdup (buf
);
9510 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9512 if (chdir (rd
->cwd
))
9514 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9515 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9516 " https://github.com/philsmd/analyze_hc_restore\n"
9517 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9523 u64
get_lowest_words_done ()
9527 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9529 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9531 if (device_param
->skipped
) continue;
9533 const u64 words_done
= device_param
->words_done
;
9535 if (words_done
< words_cur
) words_cur
= words_done
;
9538 // It's possible that a device's workload isn't finished right after a restore-case.
9539 // In that case, this function would return 0 and overwrite the real restore point
9540 // There's also data.words_cur which is set to rd->words_cur but it changes while
9541 // the attack is running therefore we should stick to rd->words_cur.
9542 // Note that -s influences rd->words_cur we should keep a close look on that.
9544 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9549 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9551 u64 words_cur
= get_lowest_words_done ();
9553 rd
->words_cur
= words_cur
;
9555 FILE *fp
= fopen (new_restore_file
, "wb");
9559 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9564 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9566 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9571 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9573 for (uint i
= 0; i
< rd
->argc
; i
++)
9575 fprintf (fp
, "%s", rd
->argv
[i
]);
9581 fsync (fileno (fp
));
9586 void cycle_restore ()
9588 const char *eff_restore_file
= data
.eff_restore_file
;
9589 const char *new_restore_file
= data
.new_restore_file
;
9591 restore_data_t
*rd
= data
.rd
;
9593 write_restore (new_restore_file
, rd
);
9597 memset (&st
, 0, sizeof(st
));
9599 if (stat (eff_restore_file
, &st
) == 0)
9601 if (unlink (eff_restore_file
))
9603 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9607 if (rename (new_restore_file
, eff_restore_file
))
9609 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9613 void check_checkpoint ()
9615 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9617 u64 words_cur
= get_lowest_words_done ();
9619 if (words_cur
!= data
.checkpoint_cur_words
)
9629 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9633 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9635 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9637 myfree (alias
->device_name
);
9638 myfree (alias
->alias_name
);
9641 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9643 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9645 myfree (entry
->device_name
);
9648 myfree (tuning_db
->alias_buf
);
9649 myfree (tuning_db
->entry_buf
);
9654 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9656 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9658 int num_lines
= count_lines (fp
);
9660 // a bit over-allocated
9662 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9663 tuning_db
->alias_cnt
= 0;
9665 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9666 tuning_db
->entry_cnt
= 0;
9671 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9673 FILE *fp
= fopen (tuning_db_file
, "rb");
9677 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9682 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9688 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9692 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9694 if (line_buf
== NULL
) break;
9698 const int line_len
= in_superchop (line_buf
);
9700 if (line_len
== 0) continue;
9702 if (line_buf
[0] == '#') continue;
9706 char *token_ptr
[7] = { NULL
};
9710 char *next
= strtok (line_buf
, "\t ");
9712 token_ptr
[token_cnt
] = next
;
9716 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9718 token_ptr
[token_cnt
] = next
;
9725 char *device_name
= token_ptr
[0];
9726 char *alias_name
= token_ptr
[1];
9728 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9730 alias
->device_name
= mystrdup (device_name
);
9731 alias
->alias_name
= mystrdup (alias_name
);
9733 tuning_db
->alias_cnt
++;
9735 else if (token_cnt
== 6)
9737 if ((token_ptr
[1][0] != '0') &&
9738 (token_ptr
[1][0] != '1') &&
9739 (token_ptr
[1][0] != '3') &&
9740 (token_ptr
[1][0] != '*'))
9742 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9747 if ((token_ptr
[3][0] != '1') &&
9748 (token_ptr
[3][0] != '2') &&
9749 (token_ptr
[3][0] != '4') &&
9750 (token_ptr
[3][0] != '8') &&
9751 (token_ptr
[3][0] != 'N'))
9753 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9758 char *device_name
= token_ptr
[0];
9760 int attack_mode
= -1;
9762 int vector_width
= -1;
9763 int kernel_accel
= -1;
9764 int kernel_loops
= -1;
9766 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9767 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9768 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9770 if (token_ptr
[4][0] != 'A')
9772 kernel_accel
= atoi (token_ptr
[4]);
9774 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9776 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9786 if (token_ptr
[5][0] != 'A')
9788 kernel_loops
= atoi (token_ptr
[5]);
9790 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9792 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9802 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9804 entry
->device_name
= mystrdup (device_name
);
9805 entry
->attack_mode
= attack_mode
;
9806 entry
->hash_type
= hash_type
;
9807 entry
->vector_width
= vector_width
;
9808 entry
->kernel_accel
= kernel_accel
;
9809 entry
->kernel_loops
= kernel_loops
;
9811 tuning_db
->entry_cnt
++;
9815 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9825 // todo: print loaded 'cnt' message
9827 // sort the database
9829 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9830 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9835 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9837 static tuning_db_entry_t s
;
9839 // first we need to convert all spaces in the device_name to underscore
9841 char *device_name_nospace
= strdup (device_param
->device_name
);
9843 int device_name_length
= strlen (device_name_nospace
);
9847 for (i
= 0; i
< device_name_length
; i
++)
9849 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9852 // find out if there's an alias configured
9854 tuning_db_alias_t a
;
9856 a
.device_name
= device_name_nospace
;
9858 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
);
9860 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9862 // attack-mode 6 and 7 are attack-mode 1 basically
9864 if (attack_mode
== 6) attack_mode
= 1;
9865 if (attack_mode
== 7) attack_mode
= 1;
9867 // bsearch is not ideal but fast enough
9869 s
.device_name
= device_name_nospace
;
9870 s
.attack_mode
= attack_mode
;
9871 s
.hash_type
= hash_type
;
9873 tuning_db_entry_t
*entry
= NULL
;
9875 // this will produce all 2^3 combinations required
9877 for (i
= 0; i
< 8; i
++)
9879 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9880 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9881 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9883 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9885 if (entry
!= NULL
) break;
9887 // in non-wildcard mode do some additional checks:
9891 // in case we have an alias-name
9893 if (alias_name
!= NULL
)
9895 s
.device_name
= alias_name
;
9897 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9899 if (entry
!= NULL
) break;
9902 // or by device type
9904 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9906 s
.device_name
= "DEVICE_TYPE_CPU";
9908 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9910 s
.device_name
= "DEVICE_TYPE_GPU";
9912 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9914 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9917 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9919 if (entry
!= NULL
) break;
9923 // free converted device_name
9925 myfree (device_name_nospace
);
9934 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9936 u8 tmp
[256] = { 0 };
9938 if (salt_len
> sizeof (tmp
))
9943 memcpy (tmp
, in
, salt_len
);
9945 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9947 if ((salt_len
% 2) == 0)
9949 u32 new_salt_len
= salt_len
/ 2;
9951 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9956 tmp
[i
] = hex_convert (p1
) << 0;
9957 tmp
[i
] |= hex_convert (p0
) << 4;
9960 salt_len
= new_salt_len
;
9967 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9969 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9972 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9974 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9978 u32
*tmp_uint
= (u32
*) tmp
;
9980 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9981 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9982 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9983 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9984 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9985 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9986 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9987 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9988 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9989 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9991 salt_len
= salt_len
* 2;
9999 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10001 lowercase (tmp
, salt_len
);
10004 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10006 uppercase (tmp
, salt_len
);
10009 u32 len
= salt_len
;
10011 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10016 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10021 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10023 u32
*tmp_uint
= (uint
*) tmp
;
10027 if (len
% 4) max
++;
10029 for (u32 i
= 0; i
< max
; i
++)
10031 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10034 // Important: we may need to increase the length of memcpy since
10035 // we don't want to "loose" some swapped bytes (could happen if
10036 // they do not perfectly fit in the 4-byte blocks)
10037 // Memcpy does always copy the bytes in the BE order, but since
10038 // we swapped them, some important bytes could be in positions
10039 // we normally skip with the original len
10041 if (len
% 4) len
+= 4 - (len
% 4);
10044 memcpy (out
, tmp
, len
);
10049 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10051 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10053 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10055 u32
*digest
= (u32
*) hash_buf
->digest
;
10057 salt_t
*salt
= hash_buf
->salt
;
10059 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10061 char *iter_pos
= input_buf
+ 4;
10063 salt
->salt_iter
= 1 << atoi (iter_pos
);
10065 char *salt_pos
= strchr (iter_pos
, '$');
10067 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10071 uint salt_len
= 16;
10073 salt
->salt_len
= salt_len
;
10075 u8 tmp_buf
[100] = { 0 };
10077 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10079 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10081 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10083 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10084 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10085 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10086 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10088 char *hash_pos
= salt_pos
+ 22;
10090 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10092 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10094 memcpy (digest
, tmp_buf
, 24);
10096 digest
[0] = byte_swap_32 (digest
[0]);
10097 digest
[1] = byte_swap_32 (digest
[1]);
10098 digest
[2] = byte_swap_32 (digest
[2]);
10099 digest
[3] = byte_swap_32 (digest
[3]);
10100 digest
[4] = byte_swap_32 (digest
[4]);
10101 digest
[5] = byte_swap_32 (digest
[5]);
10103 digest
[5] &= ~0xff; // its just 23 not 24 !
10105 return (PARSER_OK
);
10108 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10110 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10112 u32
*digest
= (u32
*) hash_buf
->digest
;
10114 u8 tmp_buf
[100] = { 0 };
10116 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10118 memcpy (digest
, tmp_buf
, 32);
10120 digest
[0] = byte_swap_32 (digest
[0]);
10121 digest
[1] = byte_swap_32 (digest
[1]);
10122 digest
[2] = byte_swap_32 (digest
[2]);
10123 digest
[3] = byte_swap_32 (digest
[3]);
10124 digest
[4] = byte_swap_32 (digest
[4]);
10125 digest
[5] = byte_swap_32 (digest
[5]);
10126 digest
[6] = byte_swap_32 (digest
[6]);
10127 digest
[7] = byte_swap_32 (digest
[7]);
10129 digest
[0] -= SHA256M_A
;
10130 digest
[1] -= SHA256M_B
;
10131 digest
[2] -= SHA256M_C
;
10132 digest
[3] -= SHA256M_D
;
10133 digest
[4] -= SHA256M_E
;
10134 digest
[5] -= SHA256M_F
;
10135 digest
[6] -= SHA256M_G
;
10136 digest
[7] -= SHA256M_H
;
10138 return (PARSER_OK
);
10141 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10143 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10145 u32
*digest
= (u32
*) hash_buf
->digest
;
10147 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10148 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10150 digest
[0] = byte_swap_32 (digest
[0]);
10151 digest
[1] = byte_swap_32 (digest
[1]);
10155 IP (digest
[0], digest
[1], tt
);
10157 digest
[0] = digest
[0];
10158 digest
[1] = digest
[1];
10162 return (PARSER_OK
);
10165 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10167 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10169 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10171 u32
*digest
= (u32
*) hash_buf
->digest
;
10173 salt_t
*salt
= hash_buf
->salt
;
10175 char *hash_pos
= input_buf
+ 10;
10177 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10178 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10179 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10180 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10181 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10183 digest
[0] -= SHA1M_A
;
10184 digest
[1] -= SHA1M_B
;
10185 digest
[2] -= SHA1M_C
;
10186 digest
[3] -= SHA1M_D
;
10187 digest
[4] -= SHA1M_E
;
10189 uint salt_len
= 10;
10191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10193 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10197 salt
->salt_len
= salt_len
;
10199 return (PARSER_OK
);
10202 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10204 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10206 u32
*digest
= (u32
*) hash_buf
->digest
;
10208 salt_t
*salt
= hash_buf
->salt
;
10210 char *hash_pos
= input_buf
+ 8;
10212 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10213 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10214 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10215 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10216 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10218 digest
[0] -= SHA1M_A
;
10219 digest
[1] -= SHA1M_B
;
10220 digest
[2] -= SHA1M_C
;
10221 digest
[3] -= SHA1M_D
;
10222 digest
[4] -= SHA1M_E
;
10226 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10228 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10230 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10232 salt
->salt_len
= salt_len
;
10234 return (PARSER_OK
);
10237 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10239 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10241 u64
*digest
= (u64
*) hash_buf
->digest
;
10243 salt_t
*salt
= hash_buf
->salt
;
10245 char *hash_pos
= input_buf
+ 8;
10247 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10248 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10249 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10250 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10251 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10252 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10253 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10254 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10256 digest
[0] -= SHA512M_A
;
10257 digest
[1] -= SHA512M_B
;
10258 digest
[2] -= SHA512M_C
;
10259 digest
[3] -= SHA512M_D
;
10260 digest
[4] -= SHA512M_E
;
10261 digest
[5] -= SHA512M_F
;
10262 digest
[6] -= SHA512M_G
;
10263 digest
[7] -= SHA512M_H
;
10267 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10269 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10273 salt
->salt_len
= salt_len
;
10275 return (PARSER_OK
);
10278 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10280 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10282 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10286 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10289 u32
*digest
= (u32
*) hash_buf
->digest
;
10291 salt_t
*salt
= hash_buf
->salt
;
10293 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10294 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10295 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10296 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10298 digest
[0] = byte_swap_32 (digest
[0]);
10299 digest
[1] = byte_swap_32 (digest
[1]);
10300 digest
[2] = byte_swap_32 (digest
[2]);
10301 digest
[3] = byte_swap_32 (digest
[3]);
10303 digest
[0] -= MD5M_A
;
10304 digest
[1] -= MD5M_B
;
10305 digest
[2] -= MD5M_C
;
10306 digest
[3] -= MD5M_D
;
10308 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10310 uint salt_len
= input_len
- 32 - 1;
10312 char *salt_buf
= input_buf
+ 32 + 1;
10314 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10316 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10318 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10320 salt
->salt_len
= salt_len
;
10322 return (PARSER_OK
);
10325 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10327 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10329 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10333 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10338 char clean_input_buf
[32] = { 0 };
10340 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10341 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10343 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10347 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10353 clean_input_buf
[k
] = input_buf
[i
];
10361 u32
*digest
= (u32
*) hash_buf
->digest
;
10363 salt_t
*salt
= hash_buf
->salt
;
10365 u32 a
, b
, c
, d
, e
, f
;
10367 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10368 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10369 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10370 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10371 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10372 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10374 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10375 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10377 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10378 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10379 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10380 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10381 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10382 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10384 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10385 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10387 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10388 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10389 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10390 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10391 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10392 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10394 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10395 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10397 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10398 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10399 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10400 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10401 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10402 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10404 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10405 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10407 digest
[0] = byte_swap_32 (digest
[0]);
10408 digest
[1] = byte_swap_32 (digest
[1]);
10409 digest
[2] = byte_swap_32 (digest
[2]);
10410 digest
[3] = byte_swap_32 (digest
[3]);
10412 digest
[0] -= MD5M_A
;
10413 digest
[1] -= MD5M_B
;
10414 digest
[2] -= MD5M_C
;
10415 digest
[3] -= MD5M_D
;
10417 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10419 uint salt_len
= input_len
- 30 - 1;
10421 char *salt_buf
= input_buf
+ 30 + 1;
10423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10427 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10428 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10430 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10432 salt
->salt_len
= salt_len
;
10434 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10436 salt
->salt_len
+= 22;
10438 return (PARSER_OK
);
10441 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10443 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10445 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10449 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10452 u32
*digest
= (u32
*) hash_buf
->digest
;
10454 salt_t
*salt
= hash_buf
->salt
;
10456 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10457 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10458 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10459 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10460 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10462 digest
[0] -= SHA1M_A
;
10463 digest
[1] -= SHA1M_B
;
10464 digest
[2] -= SHA1M_C
;
10465 digest
[3] -= SHA1M_D
;
10466 digest
[4] -= SHA1M_E
;
10468 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10470 uint salt_len
= input_len
- 40 - 1;
10472 char *salt_buf
= input_buf
+ 40 + 1;
10474 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10476 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10478 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10480 salt
->salt_len
= salt_len
;
10482 return (PARSER_OK
);
10485 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10487 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10489 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10493 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10496 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10498 char *iter_pos
= input_buf
+ 6;
10500 salt_t
*salt
= hash_buf
->salt
;
10502 uint iter
= atoi (iter_pos
);
10506 iter
= ROUNDS_DCC2
;
10509 salt
->salt_iter
= iter
- 1;
10511 char *salt_pos
= strchr (iter_pos
, '#');
10513 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10517 char *digest_pos
= strchr (salt_pos
, '#');
10519 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10523 uint salt_len
= digest_pos
- salt_pos
- 1;
10525 u32
*digest
= (u32
*) hash_buf
->digest
;
10527 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10528 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10529 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10530 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10532 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10534 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10536 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10538 salt
->salt_len
= salt_len
;
10540 return (PARSER_OK
);
10543 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10545 u32
*digest
= (u32
*) hash_buf
->digest
;
10547 salt_t
*salt
= hash_buf
->salt
;
10549 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10553 memcpy (&in
, input_buf
, input_len
);
10555 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10557 memcpy (digest
, in
.keymic
, 16);
10560 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10561 The phrase "Pairwise key expansion"
10562 Access Point Address (referred to as Authenticator Address AA)
10563 Supplicant Address (referred to as Supplicant Address SA)
10564 Access Point Nonce (referred to as Authenticator Anonce)
10565 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10568 uint salt_len
= strlen (in
.essid
);
10572 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10574 return (PARSER_SALT_LENGTH
);
10577 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10579 salt
->salt_len
= salt_len
;
10581 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10583 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10585 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10587 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10589 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10590 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10594 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10595 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10598 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10600 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10601 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10605 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10606 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10609 for (int i
= 0; i
< 25; i
++)
10611 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10614 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10615 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10616 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10617 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10619 wpa
->keyver
= in
.keyver
;
10621 if (wpa
->keyver
> 255)
10623 log_info ("ATTENTION!");
10624 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10625 log_info (" This could be due to a recent aircrack-ng bug.");
10626 log_info (" The key version was automatically reset to a reasonable value.");
10629 wpa
->keyver
&= 0xff;
10632 wpa
->eapol_size
= in
.eapol_size
;
10634 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10636 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10638 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10640 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10642 if (wpa
->keyver
== 1)
10648 digest
[0] = byte_swap_32 (digest
[0]);
10649 digest
[1] = byte_swap_32 (digest
[1]);
10650 digest
[2] = byte_swap_32 (digest
[2]);
10651 digest
[3] = byte_swap_32 (digest
[3]);
10653 for (int i
= 0; i
< 64; i
++)
10655 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10659 uint32_t *p0
= (uint32_t *) in
.essid
;
10663 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10664 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10666 salt
->salt_buf
[10] = c0
;
10667 salt
->salt_buf
[11] = c1
;
10669 return (PARSER_OK
);
10672 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10674 u32
*digest
= (u32
*) hash_buf
->digest
;
10676 salt_t
*salt
= hash_buf
->salt
;
10678 if (input_len
== 0)
10680 log_error ("Password Safe v2 container not specified");
10685 FILE *fp
= fopen (input_buf
, "rb");
10689 log_error ("%s: %s", input_buf
, strerror (errno
));
10696 memset (&buf
, 0, sizeof (psafe2_hdr
));
10698 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10702 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10704 salt
->salt_buf
[0] = buf
.random
[0];
10705 salt
->salt_buf
[1] = buf
.random
[1];
10707 salt
->salt_len
= 8;
10708 salt
->salt_iter
= 1000;
10710 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10711 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10712 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10713 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10714 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10716 return (PARSER_OK
);
10719 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10721 u32
*digest
= (u32
*) hash_buf
->digest
;
10723 salt_t
*salt
= hash_buf
->salt
;
10725 if (input_len
== 0)
10727 log_error (".psafe3 not specified");
10732 FILE *fp
= fopen (input_buf
, "rb");
10736 log_error ("%s: %s", input_buf
, strerror (errno
));
10743 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10747 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10749 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10751 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10753 salt
->salt_iter
= in
.iterations
+ 1;
10755 salt
->salt_buf
[0] = in
.salt_buf
[0];
10756 salt
->salt_buf
[1] = in
.salt_buf
[1];
10757 salt
->salt_buf
[2] = in
.salt_buf
[2];
10758 salt
->salt_buf
[3] = in
.salt_buf
[3];
10759 salt
->salt_buf
[4] = in
.salt_buf
[4];
10760 salt
->salt_buf
[5] = in
.salt_buf
[5];
10761 salt
->salt_buf
[6] = in
.salt_buf
[6];
10762 salt
->salt_buf
[7] = in
.salt_buf
[7];
10764 salt
->salt_len
= 32;
10766 digest
[0] = in
.hash_buf
[0];
10767 digest
[1] = in
.hash_buf
[1];
10768 digest
[2] = in
.hash_buf
[2];
10769 digest
[3] = in
.hash_buf
[3];
10770 digest
[4] = in
.hash_buf
[4];
10771 digest
[5] = in
.hash_buf
[5];
10772 digest
[6] = in
.hash_buf
[6];
10773 digest
[7] = in
.hash_buf
[7];
10775 digest
[0] = byte_swap_32 (digest
[0]);
10776 digest
[1] = byte_swap_32 (digest
[1]);
10777 digest
[2] = byte_swap_32 (digest
[2]);
10778 digest
[3] = byte_swap_32 (digest
[3]);
10779 digest
[4] = byte_swap_32 (digest
[4]);
10780 digest
[5] = byte_swap_32 (digest
[5]);
10781 digest
[6] = byte_swap_32 (digest
[6]);
10782 digest
[7] = byte_swap_32 (digest
[7]);
10784 return (PARSER_OK
);
10787 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10789 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10791 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10793 u32
*digest
= (u32
*) hash_buf
->digest
;
10795 salt_t
*salt
= hash_buf
->salt
;
10797 char *iter_pos
= input_buf
+ 3;
10799 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10801 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10803 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10805 salt
->salt_iter
= salt_iter
;
10807 char *salt_pos
= iter_pos
+ 1;
10811 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10813 salt
->salt_len
= salt_len
;
10815 char *hash_pos
= salt_pos
+ salt_len
;
10817 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10819 return (PARSER_OK
);
10822 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10824 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10826 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10828 u32
*digest
= (u32
*) hash_buf
->digest
;
10830 salt_t
*salt
= hash_buf
->salt
;
10832 char *salt_pos
= input_buf
+ 3;
10834 uint iterations_len
= 0;
10836 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10840 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10842 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10843 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10847 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10851 iterations_len
+= 8;
10855 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10858 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10860 char *hash_pos
= strchr (salt_pos
, '$');
10862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10864 uint salt_len
= hash_pos
- salt_pos
;
10866 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10868 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10870 salt
->salt_len
= salt_len
;
10874 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10876 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10878 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10880 return (PARSER_OK
);
10883 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10885 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10887 u32
*digest
= (u32
*) hash_buf
->digest
;
10889 salt_t
*salt
= hash_buf
->salt
;
10891 char *salt_pos
= input_buf
+ 6;
10893 uint iterations_len
= 0;
10895 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10899 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10901 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10902 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10906 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10910 iterations_len
+= 8;
10914 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10917 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10919 char *hash_pos
= strchr (salt_pos
, '$');
10921 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10923 uint salt_len
= hash_pos
- salt_pos
;
10925 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10927 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10929 salt
->salt_len
= salt_len
;
10933 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10935 return (PARSER_OK
);
10938 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10940 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10942 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10944 u32
*digest
= (u32
*) hash_buf
->digest
;
10946 salt_t
*salt
= hash_buf
->salt
;
10948 char *salt_pos
= input_buf
+ 14;
10950 char *hash_pos
= strchr (salt_pos
, '*');
10952 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10956 uint salt_len
= hash_pos
- salt_pos
- 1;
10958 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10960 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10962 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10964 salt
->salt_len
= salt_len
;
10966 u8 tmp_buf
[100] = { 0 };
10968 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10970 memcpy (digest
, tmp_buf
, 20);
10972 digest
[0] = byte_swap_32 (digest
[0]);
10973 digest
[1] = byte_swap_32 (digest
[1]);
10974 digest
[2] = byte_swap_32 (digest
[2]);
10975 digest
[3] = byte_swap_32 (digest
[3]);
10976 digest
[4] = byte_swap_32 (digest
[4]);
10978 digest
[0] -= SHA1M_A
;
10979 digest
[1] -= SHA1M_B
;
10980 digest
[2] -= SHA1M_C
;
10981 digest
[3] -= SHA1M_D
;
10982 digest
[4] -= SHA1M_E
;
10984 return (PARSER_OK
);
10987 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10989 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10991 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10993 if (c12
& 3) return (PARSER_HASH_VALUE
);
10995 u32
*digest
= (u32
*) hash_buf
->digest
;
10997 salt_t
*salt
= hash_buf
->salt
;
10999 // for ascii_digest
11000 salt
->salt_sign
[0] = input_buf
[0];
11001 salt
->salt_sign
[1] = input_buf
[1];
11003 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11004 | itoa64_to_int (input_buf
[1]) << 6;
11006 salt
->salt_len
= 2;
11008 u8 tmp_buf
[100] = { 0 };
11010 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11012 memcpy (digest
, tmp_buf
, 8);
11016 IP (digest
[0], digest
[1], tt
);
11021 return (PARSER_OK
);
11024 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11026 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11028 u32
*digest
= (u32
*) hash_buf
->digest
;
11030 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11031 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11032 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11033 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11035 digest
[0] = byte_swap_32 (digest
[0]);
11036 digest
[1] = byte_swap_32 (digest
[1]);
11037 digest
[2] = byte_swap_32 (digest
[2]);
11038 digest
[3] = byte_swap_32 (digest
[3]);
11040 digest
[0] -= MD4M_A
;
11041 digest
[1] -= MD4M_B
;
11042 digest
[2] -= MD4M_C
;
11043 digest
[3] -= MD4M_D
;
11045 return (PARSER_OK
);
11048 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11050 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11052 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11056 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11059 u32
*digest
= (u32
*) hash_buf
->digest
;
11061 salt_t
*salt
= hash_buf
->salt
;
11063 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11064 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11065 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11066 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11068 digest
[0] = byte_swap_32 (digest
[0]);
11069 digest
[1] = byte_swap_32 (digest
[1]);
11070 digest
[2] = byte_swap_32 (digest
[2]);
11071 digest
[3] = byte_swap_32 (digest
[3]);
11073 digest
[0] -= MD4M_A
;
11074 digest
[1] -= MD4M_B
;
11075 digest
[2] -= MD4M_C
;
11076 digest
[3] -= MD4M_D
;
11078 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11080 uint salt_len
= input_len
- 32 - 1;
11082 char *salt_buf
= input_buf
+ 32 + 1;
11084 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11086 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11088 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11090 salt
->salt_len
= salt_len
;
11092 return (PARSER_OK
);
11095 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11097 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11099 u32
*digest
= (u32
*) hash_buf
->digest
;
11101 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11102 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11103 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11104 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11106 digest
[0] = byte_swap_32 (digest
[0]);
11107 digest
[1] = byte_swap_32 (digest
[1]);
11108 digest
[2] = byte_swap_32 (digest
[2]);
11109 digest
[3] = byte_swap_32 (digest
[3]);
11111 digest
[0] -= MD5M_A
;
11112 digest
[1] -= MD5M_B
;
11113 digest
[2] -= MD5M_C
;
11114 digest
[3] -= MD5M_D
;
11116 return (PARSER_OK
);
11119 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11121 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11123 u32
*digest
= (u32
*) hash_buf
->digest
;
11125 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11126 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11130 digest
[0] = byte_swap_32 (digest
[0]);
11131 digest
[1] = byte_swap_32 (digest
[1]);
11133 return (PARSER_OK
);
11136 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11138 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11140 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11144 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11147 u32
*digest
= (u32
*) hash_buf
->digest
;
11149 salt_t
*salt
= hash_buf
->salt
;
11151 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11152 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11153 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11154 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11156 digest
[0] = byte_swap_32 (digest
[0]);
11157 digest
[1] = byte_swap_32 (digest
[1]);
11158 digest
[2] = byte_swap_32 (digest
[2]);
11159 digest
[3] = byte_swap_32 (digest
[3]);
11161 digest
[0] -= MD5M_A
;
11162 digest
[1] -= MD5M_B
;
11163 digest
[2] -= MD5M_C
;
11164 digest
[3] -= MD5M_D
;
11166 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11168 uint salt_len
= input_len
- 32 - 1;
11170 char *salt_buf
= input_buf
+ 32 + 1;
11172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11178 salt
->salt_len
= salt_len
;
11180 return (PARSER_OK
);
11183 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11185 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11187 u32
*digest
= (u32
*) hash_buf
->digest
;
11189 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11190 | itoa64_to_int (input_buf
[ 1]) << 6
11191 | itoa64_to_int (input_buf
[ 2]) << 12
11192 | itoa64_to_int (input_buf
[ 3]) << 18;
11193 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11194 | itoa64_to_int (input_buf
[ 5]) << 6
11195 | itoa64_to_int (input_buf
[ 6]) << 12
11196 | itoa64_to_int (input_buf
[ 7]) << 18;
11197 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11198 | itoa64_to_int (input_buf
[ 9]) << 6
11199 | itoa64_to_int (input_buf
[10]) << 12
11200 | itoa64_to_int (input_buf
[11]) << 18;
11201 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11202 | itoa64_to_int (input_buf
[13]) << 6
11203 | itoa64_to_int (input_buf
[14]) << 12
11204 | itoa64_to_int (input_buf
[15]) << 18;
11206 digest
[0] -= MD5M_A
;
11207 digest
[1] -= MD5M_B
;
11208 digest
[2] -= MD5M_C
;
11209 digest
[3] -= MD5M_D
;
11211 digest
[0] &= 0x00ffffff;
11212 digest
[1] &= 0x00ffffff;
11213 digest
[2] &= 0x00ffffff;
11214 digest
[3] &= 0x00ffffff;
11216 return (PARSER_OK
);
11219 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11221 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11223 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11227 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11230 u32
*digest
= (u32
*) hash_buf
->digest
;
11232 salt_t
*salt
= hash_buf
->salt
;
11234 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11235 | itoa64_to_int (input_buf
[ 1]) << 6
11236 | itoa64_to_int (input_buf
[ 2]) << 12
11237 | itoa64_to_int (input_buf
[ 3]) << 18;
11238 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11239 | itoa64_to_int (input_buf
[ 5]) << 6
11240 | itoa64_to_int (input_buf
[ 6]) << 12
11241 | itoa64_to_int (input_buf
[ 7]) << 18;
11242 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11243 | itoa64_to_int (input_buf
[ 9]) << 6
11244 | itoa64_to_int (input_buf
[10]) << 12
11245 | itoa64_to_int (input_buf
[11]) << 18;
11246 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11247 | itoa64_to_int (input_buf
[13]) << 6
11248 | itoa64_to_int (input_buf
[14]) << 12
11249 | itoa64_to_int (input_buf
[15]) << 18;
11251 digest
[0] -= MD5M_A
;
11252 digest
[1] -= MD5M_B
;
11253 digest
[2] -= MD5M_C
;
11254 digest
[3] -= MD5M_D
;
11256 digest
[0] &= 0x00ffffff;
11257 digest
[1] &= 0x00ffffff;
11258 digest
[2] &= 0x00ffffff;
11259 digest
[3] &= 0x00ffffff;
11261 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11263 uint salt_len
= input_len
- 16 - 1;
11265 char *salt_buf
= input_buf
+ 16 + 1;
11267 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11273 salt
->salt_len
= salt_len
;
11275 return (PARSER_OK
);
11278 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11280 key
[0] = (nthash
[0] >> 0);
11281 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11282 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11283 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11284 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11285 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11286 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11287 key
[7] = (nthash
[6] << 1);
11299 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11301 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11303 u32
*digest
= (u32
*) hash_buf
->digest
;
11305 salt_t
*salt
= hash_buf
->salt
;
11307 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11313 char *user_pos
= input_buf
;
11315 char *unused_pos
= strchr (user_pos
, ':');
11317 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11319 uint user_len
= unused_pos
- user_pos
;
11321 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11325 char *domain_pos
= strchr (unused_pos
, ':');
11327 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11329 uint unused_len
= domain_pos
- unused_pos
;
11331 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11335 char *srvchall_pos
= strchr (domain_pos
, ':');
11337 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11339 uint domain_len
= srvchall_pos
- domain_pos
;
11341 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11345 char *hash_pos
= strchr (srvchall_pos
, ':');
11347 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11349 uint srvchall_len
= hash_pos
- srvchall_pos
;
11351 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11355 char *clichall_pos
= strchr (hash_pos
, ':');
11357 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11359 uint hash_len
= clichall_pos
- hash_pos
;
11361 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11365 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11367 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11370 * store some data for later use
11373 netntlm
->user_len
= user_len
* 2;
11374 netntlm
->domain_len
= domain_len
* 2;
11375 netntlm
->srvchall_len
= srvchall_len
/ 2;
11376 netntlm
->clichall_len
= clichall_len
/ 2;
11378 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11379 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11382 * handle username and domainname
11385 for (uint i
= 0; i
< user_len
; i
++)
11387 *userdomain_ptr
++ = user_pos
[i
];
11388 *userdomain_ptr
++ = 0;
11391 for (uint i
= 0; i
< domain_len
; i
++)
11393 *userdomain_ptr
++ = domain_pos
[i
];
11394 *userdomain_ptr
++ = 0;
11398 * handle server challenge encoding
11401 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11403 const char p0
= srvchall_pos
[i
+ 0];
11404 const char p1
= srvchall_pos
[i
+ 1];
11406 *chall_ptr
++ = hex_convert (p1
) << 0
11407 | hex_convert (p0
) << 4;
11411 * handle client challenge encoding
11414 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11416 const char p0
= clichall_pos
[i
+ 0];
11417 const char p1
= clichall_pos
[i
+ 1];
11419 *chall_ptr
++ = hex_convert (p1
) << 0
11420 | hex_convert (p0
) << 4;
11427 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11429 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11431 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11433 salt
->salt_len
= salt_len
;
11435 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11436 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11437 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11438 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11440 digest
[0] = byte_swap_32 (digest
[0]);
11441 digest
[1] = byte_swap_32 (digest
[1]);
11442 digest
[2] = byte_swap_32 (digest
[2]);
11443 digest
[3] = byte_swap_32 (digest
[3]);
11445 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11447 uint digest_tmp
[2] = { 0 };
11449 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11450 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11452 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11453 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11455 /* special case 2: ESS */
11457 if (srvchall_len
== 48)
11459 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11461 uint w
[16] = { 0 };
11463 w
[ 0] = netntlm
->chall_buf
[6];
11464 w
[ 1] = netntlm
->chall_buf
[7];
11465 w
[ 2] = netntlm
->chall_buf
[0];
11466 w
[ 3] = netntlm
->chall_buf
[1];
11470 uint dgst
[4] = { 0 };
11479 salt
->salt_buf
[0] = dgst
[0];
11480 salt
->salt_buf
[1] = dgst
[1];
11484 /* precompute netntlmv1 exploit start */
11486 for (uint i
= 0; i
< 0x10000; i
++)
11488 uint key_md4
[2] = { i
, 0 };
11489 uint key_des
[2] = { 0, 0 };
11491 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11493 uint Kc
[16] = { 0 };
11494 uint Kd
[16] = { 0 };
11496 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11498 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11500 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11502 if (data3
[0] != digest_tmp
[0]) continue;
11503 if (data3
[1] != digest_tmp
[1]) continue;
11505 salt
->salt_buf
[2] = i
;
11507 salt
->salt_len
= 24;
11512 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11513 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11515 /* precompute netntlmv1 exploit stop */
11519 IP (digest
[0], digest
[1], tt
);
11520 IP (digest
[2], digest
[3], tt
);
11522 digest
[0] = rotr32 (digest
[0], 29);
11523 digest
[1] = rotr32 (digest
[1], 29);
11524 digest
[2] = rotr32 (digest
[2], 29);
11525 digest
[3] = rotr32 (digest
[3], 29);
11527 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11529 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11530 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11532 return (PARSER_OK
);
11535 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11537 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11539 u32
*digest
= (u32
*) hash_buf
->digest
;
11541 salt_t
*salt
= hash_buf
->salt
;
11543 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11549 char *user_pos
= input_buf
;
11551 char *unused_pos
= strchr (user_pos
, ':');
11553 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11555 uint user_len
= unused_pos
- user_pos
;
11557 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11561 char *domain_pos
= strchr (unused_pos
, ':');
11563 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11565 uint unused_len
= domain_pos
- unused_pos
;
11567 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11571 char *srvchall_pos
= strchr (domain_pos
, ':');
11573 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11575 uint domain_len
= srvchall_pos
- domain_pos
;
11577 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11581 char *hash_pos
= strchr (srvchall_pos
, ':');
11583 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11585 uint srvchall_len
= hash_pos
- srvchall_pos
;
11587 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11591 char *clichall_pos
= strchr (hash_pos
, ':');
11593 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11595 uint hash_len
= clichall_pos
- hash_pos
;
11597 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11601 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11603 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11605 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11608 * store some data for later use
11611 netntlm
->user_len
= user_len
* 2;
11612 netntlm
->domain_len
= domain_len
* 2;
11613 netntlm
->srvchall_len
= srvchall_len
/ 2;
11614 netntlm
->clichall_len
= clichall_len
/ 2;
11616 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11617 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11620 * handle username and domainname
11623 for (uint i
= 0; i
< user_len
; i
++)
11625 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11626 *userdomain_ptr
++ = 0;
11629 for (uint i
= 0; i
< domain_len
; i
++)
11631 *userdomain_ptr
++ = domain_pos
[i
];
11632 *userdomain_ptr
++ = 0;
11635 *userdomain_ptr
++ = 0x80;
11638 * handle server challenge encoding
11641 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11643 const char p0
= srvchall_pos
[i
+ 0];
11644 const char p1
= srvchall_pos
[i
+ 1];
11646 *chall_ptr
++ = hex_convert (p1
) << 0
11647 | hex_convert (p0
) << 4;
11651 * handle client challenge encoding
11654 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11656 const char p0
= clichall_pos
[i
+ 0];
11657 const char p1
= clichall_pos
[i
+ 1];
11659 *chall_ptr
++ = hex_convert (p1
) << 0
11660 | hex_convert (p0
) << 4;
11663 *chall_ptr
++ = 0x80;
11666 * handle hash itself
11669 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11670 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11671 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11672 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11674 digest
[0] = byte_swap_32 (digest
[0]);
11675 digest
[1] = byte_swap_32 (digest
[1]);
11676 digest
[2] = byte_swap_32 (digest
[2]);
11677 digest
[3] = byte_swap_32 (digest
[3]);
11680 * reuse challange data as salt_buf, its the buffer that is most likely unique
11683 salt
->salt_buf
[0] = 0;
11684 salt
->salt_buf
[1] = 0;
11685 salt
->salt_buf
[2] = 0;
11686 salt
->salt_buf
[3] = 0;
11687 salt
->salt_buf
[4] = 0;
11688 salt
->salt_buf
[5] = 0;
11689 salt
->salt_buf
[6] = 0;
11690 salt
->salt_buf
[7] = 0;
11694 uptr
= (uint
*) netntlm
->userdomain_buf
;
11696 for (uint i
= 0; i
< 16; i
+= 16)
11698 md5_64 (uptr
, salt
->salt_buf
);
11701 uptr
= (uint
*) netntlm
->chall_buf
;
11703 for (uint i
= 0; i
< 256; i
+= 16)
11705 md5_64 (uptr
, salt
->salt_buf
);
11708 salt
->salt_len
= 16;
11710 return (PARSER_OK
);
11713 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11715 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11717 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11721 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11724 u32
*digest
= (u32
*) hash_buf
->digest
;
11726 salt_t
*salt
= hash_buf
->salt
;
11728 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11729 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11730 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11731 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11733 digest
[0] = byte_swap_32 (digest
[0]);
11734 digest
[1] = byte_swap_32 (digest
[1]);
11735 digest
[2] = byte_swap_32 (digest
[2]);
11736 digest
[3] = byte_swap_32 (digest
[3]);
11738 digest
[0] -= MD5M_A
;
11739 digest
[1] -= MD5M_B
;
11740 digest
[2] -= MD5M_C
;
11741 digest
[3] -= MD5M_D
;
11743 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11745 uint salt_len
= input_len
- 32 - 1;
11747 char *salt_buf
= input_buf
+ 32 + 1;
11749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11751 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11753 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11755 salt
->salt_len
= salt_len
;
11757 return (PARSER_OK
);
11760 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11762 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11764 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11768 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11771 u32
*digest
= (u32
*) hash_buf
->digest
;
11773 salt_t
*salt
= hash_buf
->salt
;
11775 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11776 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11777 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11778 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11780 digest
[0] = byte_swap_32 (digest
[0]);
11781 digest
[1] = byte_swap_32 (digest
[1]);
11782 digest
[2] = byte_swap_32 (digest
[2]);
11783 digest
[3] = byte_swap_32 (digest
[3]);
11785 digest
[0] -= MD5M_A
;
11786 digest
[1] -= MD5M_B
;
11787 digest
[2] -= MD5M_C
;
11788 digest
[3] -= MD5M_D
;
11790 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11792 uint salt_len
= input_len
- 32 - 1;
11794 char *salt_buf
= input_buf
+ 32 + 1;
11796 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11798 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11800 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11802 salt
->salt_len
= salt_len
;
11804 return (PARSER_OK
);
11807 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11809 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11811 u32
*digest
= (u32
*) hash_buf
->digest
;
11813 salt_t
*salt
= hash_buf
->salt
;
11815 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11816 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11817 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11818 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11820 digest
[0] = byte_swap_32 (digest
[0]);
11821 digest
[1] = byte_swap_32 (digest
[1]);
11822 digest
[2] = byte_swap_32 (digest
[2]);
11823 digest
[3] = byte_swap_32 (digest
[3]);
11825 digest
[0] -= MD5M_A
;
11826 digest
[1] -= MD5M_B
;
11827 digest
[2] -= MD5M_C
;
11828 digest
[3] -= MD5M_D
;
11831 * This is a virtual salt. While the algorithm is basically not salted
11832 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11833 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11836 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11838 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11840 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11842 salt
->salt_len
= salt_len
;
11844 return (PARSER_OK
);
11847 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11849 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11851 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11855 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11858 u32
*digest
= (u32
*) hash_buf
->digest
;
11860 salt_t
*salt
= hash_buf
->salt
;
11862 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11863 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11864 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11865 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11867 digest
[0] = byte_swap_32 (digest
[0]);
11868 digest
[1] = byte_swap_32 (digest
[1]);
11869 digest
[2] = byte_swap_32 (digest
[2]);
11870 digest
[3] = byte_swap_32 (digest
[3]);
11872 digest
[0] -= MD5M_A
;
11873 digest
[1] -= MD5M_B
;
11874 digest
[2] -= MD5M_C
;
11875 digest
[3] -= MD5M_D
;
11877 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11879 uint salt_len
= input_len
- 32 - 1;
11881 char *salt_buf
= input_buf
+ 32 + 1;
11883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11885 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11887 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11889 salt
->salt_len
= salt_len
;
11891 return (PARSER_OK
);
11894 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11896 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11898 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11902 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11905 u32
*digest
= (u32
*) hash_buf
->digest
;
11907 salt_t
*salt
= hash_buf
->salt
;
11909 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11910 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11911 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11912 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11914 digest
[0] = byte_swap_32 (digest
[0]);
11915 digest
[1] = byte_swap_32 (digest
[1]);
11916 digest
[2] = byte_swap_32 (digest
[2]);
11917 digest
[3] = byte_swap_32 (digest
[3]);
11919 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11921 uint salt_len
= input_len
- 32 - 1;
11923 char *salt_buf
= input_buf
+ 32 + 1;
11925 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11927 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11929 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11931 salt
->salt_len
= salt_len
;
11933 return (PARSER_OK
);
11936 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11938 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11940 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11944 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11947 u32
*digest
= (u32
*) hash_buf
->digest
;
11949 salt_t
*salt
= hash_buf
->salt
;
11951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11953 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11954 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11956 digest
[0] = byte_swap_32 (digest
[0]);
11957 digest
[1] = byte_swap_32 (digest
[1]);
11958 digest
[2] = byte_swap_32 (digest
[2]);
11959 digest
[3] = byte_swap_32 (digest
[3]);
11961 digest
[0] -= MD4M_A
;
11962 digest
[1] -= MD4M_B
;
11963 digest
[2] -= MD4M_C
;
11964 digest
[3] -= MD4M_D
;
11966 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11968 uint salt_len
= input_len
- 32 - 1;
11970 char *salt_buf
= input_buf
+ 32 + 1;
11972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11974 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11978 salt
->salt_len
= salt_len
;
11980 return (PARSER_OK
);
11983 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11985 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11987 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11991 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11994 u32
*digest
= (u32
*) hash_buf
->digest
;
11996 salt_t
*salt
= hash_buf
->salt
;
11998 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11999 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12000 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12001 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12003 digest
[0] = byte_swap_32 (digest
[0]);
12004 digest
[1] = byte_swap_32 (digest
[1]);
12005 digest
[2] = byte_swap_32 (digest
[2]);
12006 digest
[3] = byte_swap_32 (digest
[3]);
12008 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12010 uint salt_len
= input_len
- 32 - 1;
12012 char *salt_buf
= input_buf
+ 32 + 1;
12014 uint salt_pc_block
[16] = { 0 };
12016 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12018 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12020 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12022 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12024 salt_pc_block
[14] = salt_len
* 8;
12026 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12028 md5_64 (salt_pc_block
, salt_pc_digest
);
12030 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12031 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12032 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12033 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12035 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12037 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12039 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12041 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12042 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12043 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12044 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12046 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12048 return (PARSER_OK
);
12051 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12053 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12055 u32
*digest
= (u32
*) hash_buf
->digest
;
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 return (PARSER_OK
);
12072 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12074 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12076 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12078 u32
*digest
= (u32
*) hash_buf
->digest
;
12082 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12083 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12084 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12085 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12088 return (PARSER_OK
);
12091 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12093 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12095 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12099 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12102 u32
*digest
= (u32
*) hash_buf
->digest
;
12104 salt_t
*salt
= hash_buf
->salt
;
12106 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12107 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12108 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12109 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12110 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12112 digest
[0] -= SHA1M_A
;
12113 digest
[1] -= SHA1M_B
;
12114 digest
[2] -= SHA1M_C
;
12115 digest
[3] -= SHA1M_D
;
12116 digest
[4] -= SHA1M_E
;
12118 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12120 uint salt_len
= input_len
- 40 - 1;
12122 char *salt_buf
= input_buf
+ 40 + 1;
12124 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12126 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12128 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12130 salt
->salt_len
= salt_len
;
12132 return (PARSER_OK
);
12135 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12137 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12139 u32
*digest
= (u32
*) hash_buf
->digest
;
12141 salt_t
*salt
= hash_buf
->salt
;
12143 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12145 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12146 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12147 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12148 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12149 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12151 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12153 uint salt_len
= input_len
- 40 - 1;
12155 char *salt_buf
= input_buf
+ 40 + 1;
12157 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12159 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12161 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12163 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12166 pstoken
->salt_len
= salt_len
/ 2;
12168 /* some fake salt for the sorting mechanisms */
12170 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12171 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12172 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12173 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12174 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12175 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12176 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12177 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12179 salt
->salt_len
= 32;
12181 /* we need to check if we can precompute some of the data --
12182 this is possible since the scheme is badly designed */
12184 pstoken
->pc_digest
[0] = SHA1M_A
;
12185 pstoken
->pc_digest
[1] = SHA1M_B
;
12186 pstoken
->pc_digest
[2] = SHA1M_C
;
12187 pstoken
->pc_digest
[3] = SHA1M_D
;
12188 pstoken
->pc_digest
[4] = SHA1M_E
;
12190 pstoken
->pc_offset
= 0;
12192 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12196 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12197 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12198 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12199 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12200 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12201 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12202 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12203 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12204 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12205 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12206 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12207 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12208 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12209 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12210 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12211 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12213 sha1_64 (w
, pstoken
->pc_digest
);
12215 pstoken
->pc_offset
+= 16;
12218 return (PARSER_OK
);
12221 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12223 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12225 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12227 u32
*digest
= (u32
*) hash_buf
->digest
;
12229 u8 tmp_buf
[100] = { 0 };
12231 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12233 memcpy (digest
, tmp_buf
, 20);
12235 digest
[0] = byte_swap_32 (digest
[0]);
12236 digest
[1] = byte_swap_32 (digest
[1]);
12237 digest
[2] = byte_swap_32 (digest
[2]);
12238 digest
[3] = byte_swap_32 (digest
[3]);
12239 digest
[4] = byte_swap_32 (digest
[4]);
12241 digest
[0] -= SHA1M_A
;
12242 digest
[1] -= SHA1M_B
;
12243 digest
[2] -= SHA1M_C
;
12244 digest
[3] -= SHA1M_D
;
12245 digest
[4] -= SHA1M_E
;
12247 return (PARSER_OK
);
12250 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12252 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12254 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12256 u32
*digest
= (u32
*) hash_buf
->digest
;
12258 salt_t
*salt
= hash_buf
->salt
;
12260 u8 tmp_buf
[100] = { 0 };
12262 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12264 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12266 memcpy (digest
, tmp_buf
, 20);
12268 int salt_len
= tmp_len
- 20;
12270 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12272 salt
->salt_len
= salt_len
;
12274 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12276 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12278 char *ptr
= (char *) salt
->salt_buf
;
12280 ptr
[salt
->salt_len
] = 0x80;
12283 digest
[0] = byte_swap_32 (digest
[0]);
12284 digest
[1] = byte_swap_32 (digest
[1]);
12285 digest
[2] = byte_swap_32 (digest
[2]);
12286 digest
[3] = byte_swap_32 (digest
[3]);
12287 digest
[4] = byte_swap_32 (digest
[4]);
12289 digest
[0] -= SHA1M_A
;
12290 digest
[1] -= SHA1M_B
;
12291 digest
[2] -= SHA1M_C
;
12292 digest
[3] -= SHA1M_D
;
12293 digest
[4] -= SHA1M_E
;
12295 return (PARSER_OK
);
12298 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12300 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12302 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12304 u32
*digest
= (u32
*) hash_buf
->digest
;
12306 salt_t
*salt
= hash_buf
->salt
;
12308 char *salt_buf
= input_buf
+ 6;
12312 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12314 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12316 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12318 salt
->salt_len
= salt_len
;
12320 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12322 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12323 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12324 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12325 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12326 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12328 digest
[0] -= SHA1M_A
;
12329 digest
[1] -= SHA1M_B
;
12330 digest
[2] -= SHA1M_C
;
12331 digest
[3] -= SHA1M_D
;
12332 digest
[4] -= SHA1M_E
;
12334 return (PARSER_OK
);
12337 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12339 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12341 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12343 u32
*digest
= (u32
*) hash_buf
->digest
;
12345 salt_t
*salt
= hash_buf
->salt
;
12347 char *salt_buf
= input_buf
+ 6;
12351 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12353 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12355 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12357 salt
->salt_len
= salt_len
;
12359 char *hash_pos
= input_buf
+ 6 + 8;
12361 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12362 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12363 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12364 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12365 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12367 digest
[0] -= SHA1M_A
;
12368 digest
[1] -= SHA1M_B
;
12369 digest
[2] -= SHA1M_C
;
12370 digest
[3] -= SHA1M_D
;
12371 digest
[4] -= SHA1M_E
;
12373 return (PARSER_OK
);
12376 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12378 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12380 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12382 u64
*digest
= (u64
*) hash_buf
->digest
;
12384 salt_t
*salt
= hash_buf
->salt
;
12386 char *salt_buf
= input_buf
+ 6;
12390 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12392 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12394 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12396 salt
->salt_len
= salt_len
;
12398 char *hash_pos
= input_buf
+ 6 + 8;
12400 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12401 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12402 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12403 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12404 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12405 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12406 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12407 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12409 digest
[0] -= SHA512M_A
;
12410 digest
[1] -= SHA512M_B
;
12411 digest
[2] -= SHA512M_C
;
12412 digest
[3] -= SHA512M_D
;
12413 digest
[4] -= SHA512M_E
;
12414 digest
[5] -= SHA512M_F
;
12415 digest
[6] -= SHA512M_G
;
12416 digest
[7] -= SHA512M_H
;
12418 return (PARSER_OK
);
12421 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12423 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12425 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12429 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12432 u32
*digest
= (u32
*) hash_buf
->digest
;
12434 salt_t
*salt
= hash_buf
->salt
;
12436 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12437 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12441 digest
[0] = byte_swap_32 (digest
[0]);
12442 digest
[1] = byte_swap_32 (digest
[1]);
12444 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12446 uint salt_len
= input_len
- 16 - 1;
12448 char *salt_buf
= input_buf
+ 16 + 1;
12450 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12452 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12454 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12456 salt
->salt_len
= salt_len
;
12458 return (PARSER_OK
);
12461 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12463 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12465 u32
*digest
= (u32
*) hash_buf
->digest
;
12467 salt_t
*salt
= hash_buf
->salt
;
12469 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12470 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12471 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12472 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12473 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12475 digest
[0] -= SHA1M_A
;
12476 digest
[1] -= SHA1M_B
;
12477 digest
[2] -= SHA1M_C
;
12478 digest
[3] -= SHA1M_D
;
12479 digest
[4] -= SHA1M_E
;
12481 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12483 uint salt_len
= input_len
- 40 - 1;
12485 char *salt_buf
= input_buf
+ 40 + 1;
12487 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12489 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12491 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12493 salt
->salt_len
= salt_len
;
12495 return (PARSER_OK
);
12498 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12500 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12502 u32
*digest
= (u32
*) hash_buf
->digest
;
12504 salt_t
*salt
= hash_buf
->salt
;
12506 char *hash_pos
= input_buf
;
12508 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12509 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12510 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12511 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12512 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12513 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12514 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12515 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12516 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12517 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12518 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12519 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12520 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12521 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12522 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12523 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12525 char *salt_pos
= input_buf
+ 128;
12527 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12528 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12529 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12530 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12532 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12533 salt
->salt_len
= 16;
12535 return (PARSER_OK
);
12538 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12540 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12542 u32
*digest
= (u32
*) hash_buf
->digest
;
12544 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12545 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12546 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12547 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12548 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12549 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12550 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12551 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12553 digest
[0] -= SHA256M_A
;
12554 digest
[1] -= SHA256M_B
;
12555 digest
[2] -= SHA256M_C
;
12556 digest
[3] -= SHA256M_D
;
12557 digest
[4] -= SHA256M_E
;
12558 digest
[5] -= SHA256M_F
;
12559 digest
[6] -= SHA256M_G
;
12560 digest
[7] -= SHA256M_H
;
12562 return (PARSER_OK
);
12565 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12567 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12569 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12573 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12576 u32
*digest
= (u32
*) hash_buf
->digest
;
12578 salt_t
*salt
= hash_buf
->salt
;
12580 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12581 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12582 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12583 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12584 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12585 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12586 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12587 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12589 digest
[0] -= SHA256M_A
;
12590 digest
[1] -= SHA256M_B
;
12591 digest
[2] -= SHA256M_C
;
12592 digest
[3] -= SHA256M_D
;
12593 digest
[4] -= SHA256M_E
;
12594 digest
[5] -= SHA256M_F
;
12595 digest
[6] -= SHA256M_G
;
12596 digest
[7] -= SHA256M_H
;
12598 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12600 uint salt_len
= input_len
- 64 - 1;
12602 char *salt_buf
= input_buf
+ 64 + 1;
12604 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12606 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12608 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12610 salt
->salt_len
= salt_len
;
12612 return (PARSER_OK
);
12615 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12617 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12619 u64
*digest
= (u64
*) hash_buf
->digest
;
12621 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12622 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12623 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12624 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12625 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12626 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12630 digest
[0] -= SHA384M_A
;
12631 digest
[1] -= SHA384M_B
;
12632 digest
[2] -= SHA384M_C
;
12633 digest
[3] -= SHA384M_D
;
12634 digest
[4] -= SHA384M_E
;
12635 digest
[5] -= SHA384M_F
;
12639 return (PARSER_OK
);
12642 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12644 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12646 u64
*digest
= (u64
*) hash_buf
->digest
;
12648 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12649 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12650 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12651 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12652 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12653 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12654 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12655 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12657 digest
[0] -= SHA512M_A
;
12658 digest
[1] -= SHA512M_B
;
12659 digest
[2] -= SHA512M_C
;
12660 digest
[3] -= SHA512M_D
;
12661 digest
[4] -= SHA512M_E
;
12662 digest
[5] -= SHA512M_F
;
12663 digest
[6] -= SHA512M_G
;
12664 digest
[7] -= SHA512M_H
;
12666 return (PARSER_OK
);
12669 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12671 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12673 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12677 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12680 u64
*digest
= (u64
*) hash_buf
->digest
;
12682 salt_t
*salt
= hash_buf
->salt
;
12684 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12685 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12686 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12687 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12688 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12689 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12690 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12691 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12693 digest
[0] -= SHA512M_A
;
12694 digest
[1] -= SHA512M_B
;
12695 digest
[2] -= SHA512M_C
;
12696 digest
[3] -= SHA512M_D
;
12697 digest
[4] -= SHA512M_E
;
12698 digest
[5] -= SHA512M_F
;
12699 digest
[6] -= SHA512M_G
;
12700 digest
[7] -= SHA512M_H
;
12702 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12704 uint salt_len
= input_len
- 128 - 1;
12706 char *salt_buf
= input_buf
+ 128 + 1;
12708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12710 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12712 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12714 salt
->salt_len
= salt_len
;
12716 return (PARSER_OK
);
12719 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12721 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12723 u64
*digest
= (u64
*) hash_buf
->digest
;
12725 salt_t
*salt
= hash_buf
->salt
;
12727 char *salt_pos
= input_buf
+ 3;
12729 uint iterations_len
= 0;
12731 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12735 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12737 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12738 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12742 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12746 iterations_len
+= 8;
12750 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12753 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12755 char *hash_pos
= strchr (salt_pos
, '$');
12757 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12759 uint salt_len
= hash_pos
- salt_pos
;
12761 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12763 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12765 salt
->salt_len
= salt_len
;
12769 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12771 return (PARSER_OK
);
12774 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12776 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12778 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12780 u64
*digest
= (u64
*) hash_buf
->digest
;
12782 salt_t
*salt
= hash_buf
->salt
;
12784 uint keccak_mdlen
= input_len
/ 2;
12786 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12788 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12790 digest
[i
] = byte_swap_64 (digest
[i
]);
12793 salt
->keccak_mdlen
= keccak_mdlen
;
12795 return (PARSER_OK
);
12798 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12800 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12802 u32
*digest
= (u32
*) hash_buf
->digest
;
12804 salt_t
*salt
= hash_buf
->salt
;
12806 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12809 * Parse that strange long line
12814 size_t in_len
[9] = { 0 };
12816 in_off
[0] = strtok (input_buf
, ":");
12818 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12820 in_len
[0] = strlen (in_off
[0]);
12824 for (i
= 1; i
< 9; i
++)
12826 in_off
[i
] = strtok (NULL
, ":");
12828 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12830 in_len
[i
] = strlen (in_off
[i
]);
12833 char *ptr
= (char *) ikepsk
->msg_buf
;
12835 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12836 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12837 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12838 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12839 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12840 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12844 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12846 ptr
= (char *) ikepsk
->nr_buf
;
12848 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12849 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12853 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12856 * Store to database
12861 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12862 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12863 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12864 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12866 digest
[0] = byte_swap_32 (digest
[0]);
12867 digest
[1] = byte_swap_32 (digest
[1]);
12868 digest
[2] = byte_swap_32 (digest
[2]);
12869 digest
[3] = byte_swap_32 (digest
[3]);
12871 salt
->salt_len
= 32;
12873 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12874 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12875 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12876 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12877 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12878 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12879 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12880 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12882 return (PARSER_OK
);
12885 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12887 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12889 u32
*digest
= (u32
*) hash_buf
->digest
;
12891 salt_t
*salt
= hash_buf
->salt
;
12893 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12896 * Parse that strange long line
12901 size_t in_len
[9] = { 0 };
12903 in_off
[0] = strtok (input_buf
, ":");
12905 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12907 in_len
[0] = strlen (in_off
[0]);
12911 for (i
= 1; i
< 9; i
++)
12913 in_off
[i
] = strtok (NULL
, ":");
12915 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12917 in_len
[i
] = strlen (in_off
[i
]);
12920 char *ptr
= (char *) ikepsk
->msg_buf
;
12922 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12923 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12924 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12925 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12926 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12927 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12931 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12933 ptr
= (char *) ikepsk
->nr_buf
;
12935 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12936 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12940 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12943 * Store to database
12948 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12949 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12950 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12951 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12952 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12954 salt
->salt_len
= 32;
12956 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12957 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12958 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12959 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12960 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12961 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12962 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12963 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12965 return (PARSER_OK
);
12968 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12970 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12972 u32
*digest
= (u32
*) hash_buf
->digest
;
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 digest
[0] = byte_swap_32 (digest
[0]);
12981 digest
[1] = byte_swap_32 (digest
[1]);
12982 digest
[2] = byte_swap_32 (digest
[2]);
12983 digest
[3] = byte_swap_32 (digest
[3]);
12984 digest
[4] = byte_swap_32 (digest
[4]);
12986 return (PARSER_OK
);
12989 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12991 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12993 u32
*digest
= (u32
*) hash_buf
->digest
;
12995 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12996 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12997 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12998 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12999 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13000 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13001 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13002 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13003 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13004 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13005 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13006 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13007 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13008 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13009 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13010 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13012 return (PARSER_OK
);
13015 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13017 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13019 u32
*digest
= (u32
*) hash_buf
->digest
;
13021 salt_t
*salt
= hash_buf
->salt
;
13023 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13024 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13025 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13026 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13027 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13029 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13031 uint salt_len
= input_len
- 40 - 1;
13033 char *salt_buf
= input_buf
+ 40 + 1;
13035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13037 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13039 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13041 salt
->salt_len
= salt_len
;
13043 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13045 return (PARSER_OK
);
13048 int truecrypt_parse_hash_1k (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_1K
- 1;
13090 tc
->signature
= 0x45555254; // "TRUE"
13092 digest
[0] = tc
->data_buf
[0];
13094 return (PARSER_OK
);
13097 int truecrypt_parse_hash_2k (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 ("TrueCrypt 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_TC_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_TRUECRYPT_2K
- 1;
13139 tc
->signature
= 0x45555254; // "TRUE"
13141 digest
[0] = tc
->data_buf
[0];
13143 return (PARSER_OK
);
13146 int veracrypt_parse_hash_200000 (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_200000
- 1;
13188 tc
->signature
= 0x41524556; // "VERA"
13190 digest
[0] = tc
->data_buf
[0];
13192 return (PARSER_OK
);
13195 int veracrypt_parse_hash_500000 (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_500000
- 1;
13237 tc
->signature
= 0x41524556; // "VERA"
13239 digest
[0] = tc
->data_buf
[0];
13241 return (PARSER_OK
);
13244 int veracrypt_parse_hash_327661 (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_327661
- 1;
13286 tc
->signature
= 0x41524556; // "VERA"
13288 digest
[0] = tc
->data_buf
[0];
13290 return (PARSER_OK
);
13293 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13295 u32
*digest
= (u32
*) hash_buf
->digest
;
13297 salt_t
*salt
= hash_buf
->salt
;
13299 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13301 if (input_len
== 0)
13303 log_error ("VeraCrypt container not specified");
13308 FILE *fp
= fopen (input_buf
, "rb");
13312 log_error ("%s: %s", input_buf
, strerror (errno
));
13317 char buf
[512] = { 0 };
13319 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13323 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13325 memcpy (tc
->salt_buf
, buf
, 64);
13327 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13329 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13331 salt
->salt_len
= 4;
13333 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13335 tc
->signature
= 0x41524556; // "VERA"
13337 digest
[0] = tc
->data_buf
[0];
13339 return (PARSER_OK
);
13342 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13344 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13346 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13348 u32
*digest
= (u32
*) hash_buf
->digest
;
13350 salt_t
*salt
= hash_buf
->salt
;
13352 char *salt_pos
= input_buf
+ 6;
13354 char *hash_pos
= strchr (salt_pos
, '$');
13356 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13358 uint salt_len
= hash_pos
- salt_pos
;
13360 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13362 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13364 salt
->salt_len
= salt_len
;
13366 salt
->salt_iter
= 1000;
13370 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13372 return (PARSER_OK
);
13375 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13377 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13379 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13381 u32
*digest
= (u32
*) hash_buf
->digest
;
13383 salt_t
*salt
= hash_buf
->salt
;
13385 char *iter_pos
= input_buf
+ 7;
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 sha1aix_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]);
13421 return (PARSER_OK
);
13424 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13426 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13428 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13430 u32
*digest
= (u32
*) hash_buf
->digest
;
13432 salt_t
*salt
= hash_buf
->salt
;
13434 char *iter_pos
= input_buf
+ 9;
13436 char *salt_pos
= strchr (iter_pos
, '$');
13438 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13442 char *hash_pos
= strchr (salt_pos
, '$');
13444 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13446 uint salt_len
= hash_pos
- salt_pos
;
13448 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13450 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13452 salt
->salt_len
= salt_len
;
13454 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13456 salt
->salt_sign
[0] = atoi (salt_iter
);
13458 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13462 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13464 digest
[0] = byte_swap_32 (digest
[0]);
13465 digest
[1] = byte_swap_32 (digest
[1]);
13466 digest
[2] = byte_swap_32 (digest
[2]);
13467 digest
[3] = byte_swap_32 (digest
[3]);
13468 digest
[4] = byte_swap_32 (digest
[4]);
13469 digest
[5] = byte_swap_32 (digest
[5]);
13470 digest
[6] = byte_swap_32 (digest
[6]);
13471 digest
[7] = byte_swap_32 (digest
[7]);
13473 return (PARSER_OK
);
13476 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13478 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13480 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13482 u64
*digest
= (u64
*) hash_buf
->digest
;
13484 salt_t
*salt
= hash_buf
->salt
;
13486 char *iter_pos
= input_buf
+ 9;
13488 char *salt_pos
= strchr (iter_pos
, '$');
13490 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13494 char *hash_pos
= strchr (salt_pos
, '$');
13496 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13498 uint salt_len
= hash_pos
- salt_pos
;
13500 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13502 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13504 salt
->salt_len
= salt_len
;
13506 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13508 salt
->salt_sign
[0] = atoi (salt_iter
);
13510 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13514 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13516 digest
[0] = byte_swap_64 (digest
[0]);
13517 digest
[1] = byte_swap_64 (digest
[1]);
13518 digest
[2] = byte_swap_64 (digest
[2]);
13519 digest
[3] = byte_swap_64 (digest
[3]);
13520 digest
[4] = byte_swap_64 (digest
[4]);
13521 digest
[5] = byte_swap_64 (digest
[5]);
13522 digest
[6] = byte_swap_64 (digest
[6]);
13523 digest
[7] = byte_swap_64 (digest
[7]);
13525 return (PARSER_OK
);
13528 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13530 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13532 u32
*digest
= (u32
*) hash_buf
->digest
;
13534 salt_t
*salt
= hash_buf
->salt
;
13536 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13542 char *iterations_pos
= input_buf
;
13544 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13546 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13548 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13550 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13554 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13556 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13558 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13560 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13562 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13564 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13569 * pbkdf2 iterations
13572 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13575 * handle salt encoding
13578 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13580 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13582 const char p0
= saltbuf_pos
[i
+ 0];
13583 const char p1
= saltbuf_pos
[i
+ 1];
13585 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13586 | hex_convert (p0
) << 4;
13589 salt
->salt_len
= saltbuf_len
/ 2;
13592 * handle cipher encoding
13595 uint
*tmp
= (uint
*) mymalloc (32);
13597 char *cipherbuf_ptr
= (char *) tmp
;
13599 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13601 const char p0
= cipherbuf_pos
[i
+ 0];
13602 const char p1
= cipherbuf_pos
[i
+ 1];
13604 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13605 | hex_convert (p0
) << 4;
13608 // iv is stored at salt_buf 4 (length 16)
13609 // data is stored at salt_buf 8 (length 16)
13611 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13612 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13613 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13614 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13616 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13617 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13618 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13619 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13623 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13625 const char p0
= cipherbuf_pos
[j
+ 0];
13626 const char p1
= cipherbuf_pos
[j
+ 1];
13628 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13629 | hex_convert (p0
) << 4;
13636 digest
[0] = 0x10101010;
13637 digest
[1] = 0x10101010;
13638 digest
[2] = 0x10101010;
13639 digest
[3] = 0x10101010;
13641 return (PARSER_OK
);
13644 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13646 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13648 u32
*digest
= (u32
*) hash_buf
->digest
;
13650 salt_t
*salt
= hash_buf
->salt
;
13652 char *hashbuf_pos
= input_buf
;
13654 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13656 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13658 uint hash_len
= iterations_pos
- hashbuf_pos
;
13660 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13664 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13666 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13668 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13672 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13674 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13676 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13678 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13680 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13682 salt
->salt_len
= salt_len
;
13684 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13686 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13687 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13688 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13689 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13691 return (PARSER_OK
);
13694 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13696 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13698 u32
*digest
= (u32
*) hash_buf
->digest
;
13700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13704 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13705 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13706 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13707 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13709 digest
[0] = byte_swap_32 (digest
[0]);
13710 digest
[1] = byte_swap_32 (digest
[1]);
13711 digest
[2] = byte_swap_32 (digest
[2]);
13712 digest
[3] = byte_swap_32 (digest
[3]);
13713 digest
[4] = byte_swap_32 (digest
[4]);
13714 digest
[5] = byte_swap_32 (digest
[5]);
13715 digest
[6] = byte_swap_32 (digest
[6]);
13716 digest
[7] = byte_swap_32 (digest
[7]);
13718 return (PARSER_OK
);
13721 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13723 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13725 u32
*digest
= (u32
*) hash_buf
->digest
;
13727 salt_t
*salt
= hash_buf
->salt
;
13729 char *salt_pos
= input_buf
+ 3;
13731 uint iterations_len
= 0;
13733 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13737 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13739 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13740 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13744 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13748 iterations_len
+= 8;
13752 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13755 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13757 char *hash_pos
= strchr (salt_pos
, '$');
13759 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13761 uint salt_len
= hash_pos
- salt_pos
;
13763 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13765 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13767 salt
->salt_len
= salt_len
;
13771 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13773 return (PARSER_OK
);
13776 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13778 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13780 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13782 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13784 u64
*digest
= (u64
*) hash_buf
->digest
;
13786 salt_t
*salt
= hash_buf
->salt
;
13788 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13790 char *iter_pos
= input_buf
+ 4;
13792 char *salt_pos
= strchr (iter_pos
, '$');
13794 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13798 char *hash_pos
= strchr (salt_pos
, '$');
13800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13802 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13806 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13807 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13808 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13809 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13810 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13811 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13812 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13813 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13815 uint salt_len
= hash_pos
- salt_pos
- 1;
13817 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13819 salt
->salt_len
= salt_len
/ 2;
13821 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13822 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13823 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13824 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13825 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13826 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13827 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13828 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13830 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13831 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13832 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13833 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13834 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13835 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13836 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13837 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13838 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13839 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13841 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13843 salt
->salt_iter
= atoi (iter_pos
) - 1;
13845 return (PARSER_OK
);
13848 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13850 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13852 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13854 u32
*digest
= (u32
*) hash_buf
->digest
;
13856 salt_t
*salt
= hash_buf
->salt
;
13858 char *salt_pos
= input_buf
+ 14;
13860 char *hash_pos
= strchr (salt_pos
, '*');
13862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13866 uint salt_len
= hash_pos
- salt_pos
- 1;
13868 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13870 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13872 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13874 salt
->salt_len
= salt_len
;
13876 u8 tmp_buf
[100] = { 0 };
13878 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13880 memcpy (digest
, tmp_buf
, 32);
13882 digest
[0] = byte_swap_32 (digest
[0]);
13883 digest
[1] = byte_swap_32 (digest
[1]);
13884 digest
[2] = byte_swap_32 (digest
[2]);
13885 digest
[3] = byte_swap_32 (digest
[3]);
13886 digest
[4] = byte_swap_32 (digest
[4]);
13887 digest
[5] = byte_swap_32 (digest
[5]);
13888 digest
[6] = byte_swap_32 (digest
[6]);
13889 digest
[7] = byte_swap_32 (digest
[7]);
13891 digest
[0] -= SHA256M_A
;
13892 digest
[1] -= SHA256M_B
;
13893 digest
[2] -= SHA256M_C
;
13894 digest
[3] -= SHA256M_D
;
13895 digest
[4] -= SHA256M_E
;
13896 digest
[5] -= SHA256M_F
;
13897 digest
[6] -= SHA256M_G
;
13898 digest
[7] -= SHA256M_H
;
13900 return (PARSER_OK
);
13903 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13905 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13907 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13909 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13911 u64
*digest
= (u64
*) hash_buf
->digest
;
13913 salt_t
*salt
= hash_buf
->salt
;
13915 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13917 char *iter_pos
= input_buf
+ 19;
13919 char *salt_pos
= strchr (iter_pos
, '.');
13921 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13925 char *hash_pos
= strchr (salt_pos
, '.');
13927 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13929 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13933 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13934 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13935 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13936 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13937 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13938 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13939 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13940 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13942 uint salt_len
= hash_pos
- salt_pos
- 1;
13946 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13950 for (i
= 0; i
< salt_len
; i
++)
13952 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13955 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13956 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13958 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13960 salt
->salt_len
= salt_len
;
13962 salt
->salt_iter
= atoi (iter_pos
) - 1;
13964 return (PARSER_OK
);
13967 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13969 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13971 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13973 u64
*digest
= (u64
*) hash_buf
->digest
;
13975 salt_t
*salt
= hash_buf
->salt
;
13977 u8 tmp_buf
[120] = { 0 };
13979 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13981 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13983 memcpy (digest
, tmp_buf
, 64);
13985 digest
[0] = byte_swap_64 (digest
[0]);
13986 digest
[1] = byte_swap_64 (digest
[1]);
13987 digest
[2] = byte_swap_64 (digest
[2]);
13988 digest
[3] = byte_swap_64 (digest
[3]);
13989 digest
[4] = byte_swap_64 (digest
[4]);
13990 digest
[5] = byte_swap_64 (digest
[5]);
13991 digest
[6] = byte_swap_64 (digest
[6]);
13992 digest
[7] = byte_swap_64 (digest
[7]);
13994 digest
[0] -= SHA512M_A
;
13995 digest
[1] -= SHA512M_B
;
13996 digest
[2] -= SHA512M_C
;
13997 digest
[3] -= SHA512M_D
;
13998 digest
[4] -= SHA512M_E
;
13999 digest
[5] -= SHA512M_F
;
14000 digest
[6] -= SHA512M_G
;
14001 digest
[7] -= SHA512M_H
;
14003 int salt_len
= tmp_len
- 64;
14005 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14007 salt
->salt_len
= salt_len
;
14009 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14011 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14013 char *ptr
= (char *) salt
->salt_buf
;
14015 ptr
[salt
->salt_len
] = 0x80;
14018 return (PARSER_OK
);
14021 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14023 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14025 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14029 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14032 u32
*digest
= (u32
*) hash_buf
->digest
;
14034 salt_t
*salt
= hash_buf
->salt
;
14036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14038 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14039 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14041 digest
[0] = byte_swap_32 (digest
[0]);
14042 digest
[1] = byte_swap_32 (digest
[1]);
14043 digest
[2] = byte_swap_32 (digest
[2]);
14044 digest
[3] = byte_swap_32 (digest
[3]);
14046 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14048 uint salt_len
= input_len
- 32 - 1;
14050 char *salt_buf
= input_buf
+ 32 + 1;
14052 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14054 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14056 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14058 salt
->salt_len
= salt_len
;
14060 return (PARSER_OK
);
14063 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14065 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14067 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14071 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14074 u32
*digest
= (u32
*) hash_buf
->digest
;
14076 salt_t
*salt
= hash_buf
->salt
;
14078 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14079 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14080 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14081 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14082 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14084 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14086 uint salt_len
= input_len
- 40 - 1;
14088 char *salt_buf
= input_buf
+ 40 + 1;
14090 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14092 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14094 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14096 salt
->salt_len
= salt_len
;
14098 return (PARSER_OK
);
14101 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14103 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14105 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14109 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14112 u32
*digest
= (u32
*) hash_buf
->digest
;
14114 salt_t
*salt
= hash_buf
->salt
;
14116 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14117 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14118 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14119 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14120 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14121 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14122 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14123 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14125 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14127 uint salt_len
= input_len
- 64 - 1;
14129 char *salt_buf
= input_buf
+ 64 + 1;
14131 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14133 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14137 salt
->salt_len
= salt_len
;
14139 return (PARSER_OK
);
14142 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14144 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14146 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14150 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14153 u64
*digest
= (u64
*) hash_buf
->digest
;
14155 salt_t
*salt
= hash_buf
->salt
;
14157 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14158 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14159 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14160 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14161 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14162 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14163 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14164 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14166 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14168 uint salt_len
= input_len
- 128 - 1;
14170 char *salt_buf
= input_buf
+ 128 + 1;
14172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14178 salt
->salt_len
= salt_len
;
14180 return (PARSER_OK
);
14183 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14185 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14187 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14189 u32
*digest
= (u32
*) hash_buf
->digest
;
14191 salt_t
*salt
= hash_buf
->salt
;
14193 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14199 char *user_pos
= input_buf
+ 10 + 1;
14201 char *realm_pos
= strchr (user_pos
, '$');
14203 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14205 uint user_len
= realm_pos
- user_pos
;
14207 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14211 char *salt_pos
= strchr (realm_pos
, '$');
14213 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14215 uint realm_len
= salt_pos
- realm_pos
;
14217 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14221 char *data_pos
= strchr (salt_pos
, '$');
14223 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14225 uint salt_len
= data_pos
- salt_pos
;
14227 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14231 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14233 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14239 memcpy (krb5pa
->user
, user_pos
, user_len
);
14240 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14241 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14243 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14245 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14247 const char p0
= data_pos
[i
+ 0];
14248 const char p1
= data_pos
[i
+ 1];
14250 *timestamp_ptr
++ = hex_convert (p1
) << 0
14251 | hex_convert (p0
) << 4;
14254 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14256 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14258 const char p0
= data_pos
[i
+ 0];
14259 const char p1
= data_pos
[i
+ 1];
14261 *checksum_ptr
++ = hex_convert (p1
) << 0
14262 | hex_convert (p0
) << 4;
14266 * copy some data to generic buffers to make sorting happy
14269 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14270 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14271 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14272 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14273 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14274 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14275 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14276 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14277 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14279 salt
->salt_len
= 36;
14281 digest
[0] = krb5pa
->checksum
[0];
14282 digest
[1] = krb5pa
->checksum
[1];
14283 digest
[2] = krb5pa
->checksum
[2];
14284 digest
[3] = krb5pa
->checksum
[3];
14286 return (PARSER_OK
);
14289 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14291 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14293 u32
*digest
= (u32
*) hash_buf
->digest
;
14295 salt_t
*salt
= hash_buf
->salt
;
14301 char *salt_pos
= input_buf
;
14303 char *hash_pos
= strchr (salt_pos
, '$');
14305 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14307 uint salt_len
= hash_pos
- salt_pos
;
14309 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14313 uint hash_len
= input_len
- 1 - salt_len
;
14315 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14323 for (uint i
= 0; i
< salt_len
; i
++)
14325 if (salt_pos
[i
] == ' ') continue;
14330 // SAP user names cannot be longer than 12 characters
14331 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14333 // SAP user name cannot start with ! or ?
14334 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14340 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14346 salt
->salt_len
= salt_len
;
14348 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14349 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14353 digest
[0] = byte_swap_32 (digest
[0]);
14354 digest
[1] = byte_swap_32 (digest
[1]);
14356 return (PARSER_OK
);
14359 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14361 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14363 u32
*digest
= (u32
*) hash_buf
->digest
;
14365 salt_t
*salt
= hash_buf
->salt
;
14371 char *salt_pos
= input_buf
;
14373 char *hash_pos
= strchr (salt_pos
, '$');
14375 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14377 uint salt_len
= hash_pos
- salt_pos
;
14379 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14383 uint hash_len
= input_len
- 1 - salt_len
;
14385 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14393 for (uint i
= 0; i
< salt_len
; i
++)
14395 if (salt_pos
[i
] == ' ') continue;
14400 // SAP user names cannot be longer than 12 characters
14401 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14402 // so far nobody complained so we stay with this because it helps in optimization
14403 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14405 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14407 // SAP user name cannot start with ! or ?
14408 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14414 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14418 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14420 salt
->salt_len
= salt_len
;
14422 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14423 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14424 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14425 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14426 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14428 return (PARSER_OK
);
14431 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14433 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14435 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14437 u64
*digest
= (u64
*) hash_buf
->digest
;
14439 salt_t
*salt
= hash_buf
->salt
;
14441 char *iter_pos
= input_buf
+ 3;
14443 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14445 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14447 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14449 salt
->salt_iter
= salt_iter
;
14451 char *salt_pos
= iter_pos
+ 1;
14455 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14457 salt
->salt_len
= salt_len
;
14459 char *hash_pos
= salt_pos
+ salt_len
;
14461 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14465 char *tmp
= (char *) salt
->salt_buf_pc
;
14467 tmp
[0] = hash_pos
[42];
14471 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14472 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14473 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14474 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14480 return (PARSER_OK
);
14483 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14485 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14487 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14489 u32
*digest
= (u32
*) hash_buf
->digest
;
14491 salt_t
*salt
= hash_buf
->salt
;
14493 char *salt_buf
= input_buf
+ 6;
14495 uint salt_len
= 16;
14497 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14499 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14501 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14503 salt
->salt_len
= salt_len
;
14505 char *hash_pos
= input_buf
+ 6 + 16;
14507 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14508 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14509 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14510 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14511 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14512 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14513 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14514 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14516 return (PARSER_OK
);
14519 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14521 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14523 u32
*digest
= (u32
*) hash_buf
->digest
;
14525 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14526 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14530 return (PARSER_OK
);
14533 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14535 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14537 u32
*digest
= (u32
*) hash_buf
->digest
;
14539 salt_t
*salt
= hash_buf
->salt
;
14541 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14543 char *saltbuf_pos
= input_buf
;
14545 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14547 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14549 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14551 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14552 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14554 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14558 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14560 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14562 char *salt_ptr
= (char *) saltbuf_pos
;
14563 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14568 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14570 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14573 rakp_ptr
[j
] = 0x80;
14575 rakp
->salt_len
= j
;
14577 for (i
= 0; i
< 64; i
++)
14579 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14582 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14583 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14584 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14585 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14586 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14587 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14588 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14589 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14591 salt
->salt_len
= 32; // muss min. 32 haben
14593 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14594 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14595 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14596 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14597 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14599 return (PARSER_OK
);
14602 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14604 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14606 u32
*digest
= (u32
*) hash_buf
->digest
;
14608 salt_t
*salt
= hash_buf
->salt
;
14610 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14612 char *salt_pos
= input_buf
+ 1;
14614 memcpy (salt
->salt_buf
, salt_pos
, 8);
14616 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14617 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14619 salt
->salt_len
= 8;
14621 char *hash_pos
= salt_pos
+ 8;
14623 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14624 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14625 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14626 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14627 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14629 digest
[0] -= SHA1M_A
;
14630 digest
[1] -= SHA1M_B
;
14631 digest
[2] -= SHA1M_C
;
14632 digest
[3] -= SHA1M_D
;
14633 digest
[4] -= SHA1M_E
;
14635 return (PARSER_OK
);
14638 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14640 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14642 u32
*digest
= (u32
*) hash_buf
->digest
;
14644 salt_t
*salt
= hash_buf
->salt
;
14646 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14647 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14648 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14649 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14651 digest
[0] = byte_swap_32 (digest
[0]);
14652 digest
[1] = byte_swap_32 (digest
[1]);
14653 digest
[2] = byte_swap_32 (digest
[2]);
14654 digest
[3] = byte_swap_32 (digest
[3]);
14656 digest
[0] -= MD5M_A
;
14657 digest
[1] -= MD5M_B
;
14658 digest
[2] -= MD5M_C
;
14659 digest
[3] -= MD5M_D
;
14661 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14663 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14665 u32
*salt_buf
= salt
->salt_buf
;
14667 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14668 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14669 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14670 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14672 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14673 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14674 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14675 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14677 salt
->salt_len
= 16 + 1;
14679 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14681 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14683 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14685 return (PARSER_OK
);
14688 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14690 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14692 u32
*digest
= (u32
*) hash_buf
->digest
;
14694 salt_t
*salt
= hash_buf
->salt
;
14696 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14702 char *hashbuf_pos
= input_buf
;
14704 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14706 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14708 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14710 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14714 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14716 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14718 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14720 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14724 char *databuf_pos
= strchr (iteration_pos
, ':');
14726 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14728 const uint iteration_len
= databuf_pos
- iteration_pos
;
14730 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14731 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14733 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14735 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14736 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14742 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14743 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14744 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14745 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14746 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14747 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14748 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14749 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14753 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14755 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14757 const char p0
= saltbuf_pos
[i
+ 0];
14758 const char p1
= saltbuf_pos
[i
+ 1];
14760 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14761 | hex_convert (p0
) << 4;
14764 salt
->salt_buf
[4] = 0x01000000;
14765 salt
->salt_buf
[5] = 0x80;
14767 salt
->salt_len
= saltbuf_len
/ 2;
14771 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14775 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14777 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14779 const char p0
= databuf_pos
[i
+ 0];
14780 const char p1
= databuf_pos
[i
+ 1];
14782 *databuf_ptr
++ = hex_convert (p1
) << 0
14783 | hex_convert (p0
) << 4;
14786 *databuf_ptr
++ = 0x80;
14788 for (uint i
= 0; i
< 512; i
++)
14790 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14793 cloudkey
->data_len
= databuf_len
/ 2;
14795 return (PARSER_OK
);
14798 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14800 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14802 u32
*digest
= (u32
*) hash_buf
->digest
;
14804 salt_t
*salt
= hash_buf
->salt
;
14810 char *hashbuf_pos
= input_buf
;
14812 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14814 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14816 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14818 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14822 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14824 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14826 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14828 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14830 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14834 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14836 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14838 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14840 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14842 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14846 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14848 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14849 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14851 // ok, the plan for this algorithm is the following:
14852 // we have 2 salts here, the domain-name and a random salt
14853 // while both are used in the initial transformation,
14854 // only the random salt is used in the following iterations
14855 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14856 // and one that includes only the real salt (stored into salt_buf[]).
14857 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14859 u8 tmp_buf
[100] = { 0 };
14861 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14863 memcpy (digest
, tmp_buf
, 20);
14865 digest
[0] = byte_swap_32 (digest
[0]);
14866 digest
[1] = byte_swap_32 (digest
[1]);
14867 digest
[2] = byte_swap_32 (digest
[2]);
14868 digest
[3] = byte_swap_32 (digest
[3]);
14869 digest
[4] = byte_swap_32 (digest
[4]);
14873 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14875 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14877 char *len_ptr
= NULL
;
14879 for (uint i
= 0; i
< domainbuf_len
; i
++)
14881 if (salt_buf_pc_ptr
[i
] == '.')
14883 len_ptr
= &salt_buf_pc_ptr
[i
];
14893 salt
->salt_buf_pc
[7] = domainbuf_len
;
14897 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14899 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14901 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14903 salt
->salt_len
= salt_len
;
14907 salt
->salt_iter
= atoi (iteration_pos
);
14909 return (PARSER_OK
);
14912 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14914 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14916 u32
*digest
= (u32
*) hash_buf
->digest
;
14918 salt_t
*salt
= hash_buf
->salt
;
14920 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14921 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14922 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14923 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14924 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14926 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14928 uint salt_len
= input_len
- 40 - 1;
14930 char *salt_buf
= input_buf
+ 40 + 1;
14932 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14934 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14936 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14938 salt
->salt_len
= salt_len
;
14940 return (PARSER_OK
);
14943 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14945 const u8 ascii_to_ebcdic
[] =
14947 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14948 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14949 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14950 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14951 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14952 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14953 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14954 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14955 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14956 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14957 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14958 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14959 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14960 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14961 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14962 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14965 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14967 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14969 u32
*digest
= (u32
*) hash_buf
->digest
;
14971 salt_t
*salt
= hash_buf
->salt
;
14973 char *salt_pos
= input_buf
+ 6 + 1;
14975 char *digest_pos
= strchr (salt_pos
, '*');
14977 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14979 uint salt_len
= digest_pos
- salt_pos
;
14981 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14983 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14985 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14989 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14990 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14992 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14994 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14996 salt
->salt_len
= salt_len
;
14998 for (uint i
= 0; i
< salt_len
; i
++)
15000 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15002 for (uint i
= salt_len
; i
< 8; i
++)
15004 salt_buf_pc_ptr
[i
] = 0x40;
15009 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15011 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15012 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15014 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15015 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15017 digest
[0] = byte_swap_32 (digest
[0]);
15018 digest
[1] = byte_swap_32 (digest
[1]);
15020 IP (digest
[0], digest
[1], tt
);
15022 digest
[0] = rotr32 (digest
[0], 29);
15023 digest
[1] = rotr32 (digest
[1], 29);
15027 return (PARSER_OK
);
15030 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15032 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15034 u32
*digest
= (u32
*) hash_buf
->digest
;
15036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15038 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15039 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15041 digest
[0] = byte_swap_32 (digest
[0]);
15042 digest
[1] = byte_swap_32 (digest
[1]);
15043 digest
[2] = byte_swap_32 (digest
[2]);
15044 digest
[3] = byte_swap_32 (digest
[3]);
15046 return (PARSER_OK
);
15049 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15051 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15053 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15055 u32
*digest
= (u32
*) hash_buf
->digest
;
15057 salt_t
*salt
= hash_buf
->salt
;
15059 u8 tmp_buf
[120] = { 0 };
15061 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15063 tmp_buf
[3] += -4; // dont ask!
15065 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15067 salt
->salt_len
= 5;
15069 memcpy (digest
, tmp_buf
+ 5, 9);
15071 // yes, only 9 byte are needed to crack, but 10 to display
15073 salt
->salt_buf_pc
[7] = input_buf
[20];
15075 return (PARSER_OK
);
15078 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15080 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15082 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15084 u32
*digest
= (u32
*) hash_buf
->digest
;
15086 salt_t
*salt
= hash_buf
->salt
;
15088 u8 tmp_buf
[120] = { 0 };
15090 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15092 tmp_buf
[3] += -4; // dont ask!
15096 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15098 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)
15102 char tmp_iter_buf
[11] = { 0 };
15104 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15106 tmp_iter_buf
[10] = 0;
15108 salt
->salt_iter
= atoi (tmp_iter_buf
);
15110 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15112 return (PARSER_SALT_ITERATION
);
15115 salt
->salt_iter
--; // first round in init
15117 // 2 additional bytes for display only
15119 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15120 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15124 memcpy (digest
, tmp_buf
+ 28, 8);
15126 digest
[0] = byte_swap_32 (digest
[0]);
15127 digest
[1] = byte_swap_32 (digest
[1]);
15131 return (PARSER_OK
);
15134 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15136 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15138 u32
*digest
= (u32
*) hash_buf
->digest
;
15140 salt_t
*salt
= hash_buf
->salt
;
15142 char *salt_buf_pos
= input_buf
;
15144 char *hash_buf_pos
= salt_buf_pos
+ 6;
15146 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15147 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15148 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15149 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15150 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15151 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15152 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15153 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15155 digest
[0] -= SHA256M_A
;
15156 digest
[1] -= SHA256M_B
;
15157 digest
[2] -= SHA256M_C
;
15158 digest
[3] -= SHA256M_D
;
15159 digest
[4] -= SHA256M_E
;
15160 digest
[5] -= SHA256M_F
;
15161 digest
[6] -= SHA256M_G
;
15162 digest
[7] -= SHA256M_H
;
15164 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15166 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15168 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15170 salt
->salt_len
= salt_len
;
15172 return (PARSER_OK
);
15175 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15177 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15179 u32
*digest
= (u32
*) hash_buf
->digest
;
15181 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15183 salt_t
*salt
= hash_buf
->salt
;
15185 char *salt_buf
= input_buf
+ 6;
15187 char *digest_buf
= strchr (salt_buf
, '$');
15189 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15191 uint salt_len
= digest_buf
- salt_buf
;
15193 digest_buf
++; // skip the '$' symbol
15195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15197 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15199 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15201 salt
->salt_len
= salt_len
;
15203 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15204 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15205 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15206 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15208 digest
[0] = byte_swap_32 (digest
[0]);
15209 digest
[1] = byte_swap_32 (digest
[1]);
15210 digest
[2] = byte_swap_32 (digest
[2]);
15211 digest
[3] = byte_swap_32 (digest
[3]);
15213 digest
[0] -= MD5M_A
;
15214 digest
[1] -= MD5M_B
;
15215 digest
[2] -= MD5M_C
;
15216 digest
[3] -= MD5M_D
;
15218 return (PARSER_OK
);
15221 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15223 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15225 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15227 u32
*digest
= (u32
*) hash_buf
->digest
;
15229 salt_t
*salt
= hash_buf
->salt
;
15231 char *salt_buf
= input_buf
+ 3;
15233 char *digest_buf
= strchr (salt_buf
, '$');
15235 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15237 uint salt_len
= digest_buf
- salt_buf
;
15239 digest_buf
++; // skip the '$' symbol
15241 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15243 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15245 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15247 salt_buf_ptr
[salt_len
] = 0x2d;
15249 salt
->salt_len
= salt_len
+ 1;
15251 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15252 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15253 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15254 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15256 digest
[0] = byte_swap_32 (digest
[0]);
15257 digest
[1] = byte_swap_32 (digest
[1]);
15258 digest
[2] = byte_swap_32 (digest
[2]);
15259 digest
[3] = byte_swap_32 (digest
[3]);
15261 digest
[0] -= MD5M_A
;
15262 digest
[1] -= MD5M_B
;
15263 digest
[2] -= MD5M_C
;
15264 digest
[3] -= MD5M_D
;
15266 return (PARSER_OK
);
15269 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15271 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15273 u32
*digest
= (u32
*) hash_buf
->digest
;
15275 salt_t
*salt
= hash_buf
->salt
;
15277 u8 tmp_buf
[100] = { 0 };
15279 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15281 memcpy (digest
, tmp_buf
, 20);
15283 digest
[0] = byte_swap_32 (digest
[0]);
15284 digest
[1] = byte_swap_32 (digest
[1]);
15285 digest
[2] = byte_swap_32 (digest
[2]);
15286 digest
[3] = byte_swap_32 (digest
[3]);
15287 digest
[4] = byte_swap_32 (digest
[4]);
15289 digest
[0] -= SHA1M_A
;
15290 digest
[1] -= SHA1M_B
;
15291 digest
[2] -= SHA1M_C
;
15292 digest
[3] -= SHA1M_D
;
15293 digest
[4] -= SHA1M_E
;
15295 salt
->salt_buf
[0] = 0x80;
15297 salt
->salt_len
= 0;
15299 return (PARSER_OK
);
15302 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15304 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15306 u32
*digest
= (u32
*) hash_buf
->digest
;
15308 salt_t
*salt
= hash_buf
->salt
;
15310 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15311 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15312 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15313 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15315 digest
[0] = byte_swap_32 (digest
[0]);
15316 digest
[1] = byte_swap_32 (digest
[1]);
15317 digest
[2] = byte_swap_32 (digest
[2]);
15318 digest
[3] = byte_swap_32 (digest
[3]);
15320 digest
[0] -= MD5M_A
;
15321 digest
[1] -= MD5M_B
;
15322 digest
[2] -= MD5M_C
;
15323 digest
[3] -= MD5M_D
;
15325 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15327 uint salt_len
= input_len
- 32 - 1;
15329 char *salt_buf
= input_buf
+ 32 + 1;
15331 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15333 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15335 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15338 * add static "salt" part
15341 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15345 salt
->salt_len
= salt_len
;
15347 return (PARSER_OK
);
15350 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15352 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15354 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15356 u32
*digest
= (u32
*) hash_buf
->digest
;
15358 salt_t
*salt
= hash_buf
->salt
;
15360 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15366 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15368 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15370 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15372 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15374 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15378 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15380 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15382 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15384 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15388 char *keybuf_pos
= strchr (keylen_pos
, '$');
15390 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15392 uint keylen_len
= keybuf_pos
- keylen_pos
;
15394 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15398 char *databuf_pos
= strchr (keybuf_pos
, '$');
15400 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15402 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15404 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15408 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15410 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15416 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15417 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15418 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15419 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15421 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15422 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15423 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15424 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15426 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15427 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15428 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15429 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15431 salt
->salt_len
= 16;
15432 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15434 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15436 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15439 return (PARSER_OK
);
15442 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15444 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15446 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15448 u32
*digest
= (u32
*) hash_buf
->digest
;
15450 salt_t
*salt
= hash_buf
->salt
;
15456 // first is the N salt parameter
15458 char *N_pos
= input_buf
+ 6;
15460 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15464 salt
->scrypt_N
= atoi (N_pos
);
15468 char *r_pos
= strchr (N_pos
, ':');
15470 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15474 salt
->scrypt_r
= atoi (r_pos
);
15478 char *p_pos
= strchr (r_pos
, ':');
15480 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15484 salt
->scrypt_p
= atoi (p_pos
);
15488 char *saltbuf_pos
= strchr (p_pos
, ':');
15490 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15494 char *hash_pos
= strchr (saltbuf_pos
, ':');
15496 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15502 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15504 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15506 u8 tmp_buf
[33] = { 0 };
15508 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15510 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15512 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15514 salt
->salt_len
= tmp_len
;
15515 salt
->salt_iter
= 1;
15517 // digest - base64 decode
15519 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15521 tmp_len
= input_len
- (hash_pos
- input_buf
);
15523 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15525 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15527 memcpy (digest
, tmp_buf
, 32);
15529 return (PARSER_OK
);
15532 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15534 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15536 u32
*digest
= (u32
*) hash_buf
->digest
;
15538 salt_t
*salt
= hash_buf
->salt
;
15544 char decrypted
[76] = { 0 }; // iv + hash
15546 juniper_decrypt_hash (input_buf
, decrypted
);
15548 char *md5crypt_hash
= decrypted
+ 12;
15550 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15552 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15554 char *salt_pos
= md5crypt_hash
+ 3;
15556 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15558 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15560 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15564 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15566 return (PARSER_OK
);
15569 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15571 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15573 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15575 u32
*digest
= (u32
*) hash_buf
->digest
;
15577 salt_t
*salt
= hash_buf
->salt
;
15579 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15585 // first is *raw* salt
15587 char *salt_pos
= input_buf
+ 3;
15589 char *hash_pos
= strchr (salt_pos
, '$');
15591 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15593 uint salt_len
= hash_pos
- salt_pos
;
15595 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15599 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15601 memcpy (salt_buf_ptr
, salt_pos
, 14);
15603 salt_buf_ptr
[17] = 0x01;
15604 salt_buf_ptr
[18] = 0x80;
15606 // add some stuff to normal salt to make sorted happy
15608 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15609 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15610 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15611 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15613 salt
->salt_len
= salt_len
;
15614 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15616 // base64 decode hash
15618 u8 tmp_buf
[100] = { 0 };
15620 uint hash_len
= input_len
- 3 - salt_len
- 1;
15622 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15624 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15626 memcpy (digest
, tmp_buf
, 32);
15628 digest
[0] = byte_swap_32 (digest
[0]);
15629 digest
[1] = byte_swap_32 (digest
[1]);
15630 digest
[2] = byte_swap_32 (digest
[2]);
15631 digest
[3] = byte_swap_32 (digest
[3]);
15632 digest
[4] = byte_swap_32 (digest
[4]);
15633 digest
[5] = byte_swap_32 (digest
[5]);
15634 digest
[6] = byte_swap_32 (digest
[6]);
15635 digest
[7] = byte_swap_32 (digest
[7]);
15637 return (PARSER_OK
);
15640 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15642 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15644 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15646 u32
*digest
= (u32
*) hash_buf
->digest
;
15648 salt_t
*salt
= hash_buf
->salt
;
15654 // first is *raw* salt
15656 char *salt_pos
= input_buf
+ 3;
15658 char *hash_pos
= strchr (salt_pos
, '$');
15660 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15662 uint salt_len
= hash_pos
- salt_pos
;
15664 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15666 salt
->salt_len
= salt_len
;
15669 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15671 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15672 salt_buf_ptr
[salt_len
] = 0;
15674 // base64 decode hash
15676 u8 tmp_buf
[100] = { 0 };
15678 uint hash_len
= input_len
- 3 - salt_len
- 1;
15680 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15682 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15684 memcpy (digest
, tmp_buf
, 32);
15687 salt
->scrypt_N
= 16384;
15688 salt
->scrypt_r
= 1;
15689 salt
->scrypt_p
= 1;
15690 salt
->salt_iter
= 1;
15692 return (PARSER_OK
);
15695 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15697 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15699 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15701 u32
*digest
= (u32
*) hash_buf
->digest
;
15703 salt_t
*salt
= hash_buf
->salt
;
15705 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15711 char *version_pos
= input_buf
+ 8 + 1;
15713 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15715 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15717 u32 version_len
= verifierHashSize_pos
- version_pos
;
15719 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15721 verifierHashSize_pos
++;
15723 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15725 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15727 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15729 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15733 char *saltSize_pos
= strchr (keySize_pos
, '*');
15735 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15737 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15739 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15743 char *osalt_pos
= strchr (saltSize_pos
, '*');
15745 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15747 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15749 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15753 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15755 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15757 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15759 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15761 encryptedVerifier_pos
++;
15763 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15765 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15769 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15771 encryptedVerifierHash_pos
++;
15773 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;
15775 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15777 const uint version
= atoi (version_pos
);
15779 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15781 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15783 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15785 const uint keySize
= atoi (keySize_pos
);
15787 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15789 office2007
->keySize
= keySize
;
15791 const uint saltSize
= atoi (saltSize_pos
);
15793 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15799 salt
->salt_len
= 16;
15800 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15802 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15803 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15804 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15805 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15811 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15812 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15813 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15814 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15816 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15817 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15818 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15819 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15820 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15826 digest
[0] = office2007
->encryptedVerifierHash
[0];
15827 digest
[1] = office2007
->encryptedVerifierHash
[1];
15828 digest
[2] = office2007
->encryptedVerifierHash
[2];
15829 digest
[3] = office2007
->encryptedVerifierHash
[3];
15831 return (PARSER_OK
);
15834 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15836 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15838 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15840 u32
*digest
= (u32
*) hash_buf
->digest
;
15842 salt_t
*salt
= hash_buf
->salt
;
15844 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15850 char *version_pos
= input_buf
+ 8 + 1;
15852 char *spinCount_pos
= strchr (version_pos
, '*');
15854 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15856 u32 version_len
= spinCount_pos
- version_pos
;
15858 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15862 char *keySize_pos
= strchr (spinCount_pos
, '*');
15864 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15866 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15868 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15872 char *saltSize_pos
= strchr (keySize_pos
, '*');
15874 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15876 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15878 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15882 char *osalt_pos
= strchr (saltSize_pos
, '*');
15884 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15886 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15888 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15892 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15894 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15896 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15898 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15900 encryptedVerifier_pos
++;
15902 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15904 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15906 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15908 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15910 encryptedVerifierHash_pos
++;
15912 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;
15914 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15916 const uint version
= atoi (version_pos
);
15918 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15920 const uint spinCount
= atoi (spinCount_pos
);
15922 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15924 const uint keySize
= atoi (keySize_pos
);
15926 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15928 const uint saltSize
= atoi (saltSize_pos
);
15930 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15936 salt
->salt_len
= 16;
15937 salt
->salt_iter
= spinCount
;
15939 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15940 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15941 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15942 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15948 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15949 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15950 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15951 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15953 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15954 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15955 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15956 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15957 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15958 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15959 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15960 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15966 digest
[0] = office2010
->encryptedVerifierHash
[0];
15967 digest
[1] = office2010
->encryptedVerifierHash
[1];
15968 digest
[2] = office2010
->encryptedVerifierHash
[2];
15969 digest
[3] = office2010
->encryptedVerifierHash
[3];
15971 return (PARSER_OK
);
15974 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15976 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15978 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15980 u32
*digest
= (u32
*) hash_buf
->digest
;
15982 salt_t
*salt
= hash_buf
->salt
;
15984 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15990 char *version_pos
= input_buf
+ 8 + 1;
15992 char *spinCount_pos
= strchr (version_pos
, '*');
15994 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15996 u32 version_len
= spinCount_pos
- version_pos
;
15998 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16002 char *keySize_pos
= strchr (spinCount_pos
, '*');
16004 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16006 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16008 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16012 char *saltSize_pos
= strchr (keySize_pos
, '*');
16014 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16016 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16018 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16022 char *osalt_pos
= strchr (saltSize_pos
, '*');
16024 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16026 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16028 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16032 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16034 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16036 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16038 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16040 encryptedVerifier_pos
++;
16042 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16044 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16046 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16048 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16050 encryptedVerifierHash_pos
++;
16052 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;
16054 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16056 const uint version
= atoi (version_pos
);
16058 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16060 const uint spinCount
= atoi (spinCount_pos
);
16062 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16064 const uint keySize
= atoi (keySize_pos
);
16066 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16068 const uint saltSize
= atoi (saltSize_pos
);
16070 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16076 salt
->salt_len
= 16;
16077 salt
->salt_iter
= spinCount
;
16079 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16080 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16081 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16082 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16088 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16089 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16090 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16091 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16093 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16094 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16095 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16096 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16097 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16098 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16099 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16100 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16106 digest
[0] = office2013
->encryptedVerifierHash
[0];
16107 digest
[1] = office2013
->encryptedVerifierHash
[1];
16108 digest
[2] = office2013
->encryptedVerifierHash
[2];
16109 digest
[3] = office2013
->encryptedVerifierHash
[3];
16111 return (PARSER_OK
);
16114 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16116 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16118 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16120 u32
*digest
= (u32
*) hash_buf
->digest
;
16122 salt_t
*salt
= hash_buf
->salt
;
16124 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16130 char *version_pos
= input_buf
+ 11;
16132 char *osalt_pos
= strchr (version_pos
, '*');
16134 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16136 u32 version_len
= osalt_pos
- version_pos
;
16138 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16142 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16144 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16146 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16148 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16150 encryptedVerifier_pos
++;
16152 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16154 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16156 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16158 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16160 encryptedVerifierHash_pos
++;
16162 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16164 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16166 const uint version
= *version_pos
- 0x30;
16168 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16174 oldoffice01
->version
= version
;
16176 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16177 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16178 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16179 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16181 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16182 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16183 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16184 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16186 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16187 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16188 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16189 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16191 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16192 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16193 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16194 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16200 salt
->salt_len
= 16;
16202 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16203 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16204 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16205 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16207 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16208 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16209 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16210 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16212 // this is a workaround as office produces multiple documents with the same salt
16214 salt
->salt_len
+= 32;
16216 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16217 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16218 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16219 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16220 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16221 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16222 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16223 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16229 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16230 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16231 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16232 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16234 return (PARSER_OK
);
16237 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16239 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16242 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16244 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16246 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16248 u32
*digest
= (u32
*) hash_buf
->digest
;
16250 salt_t
*salt
= hash_buf
->salt
;
16252 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16258 char *version_pos
= input_buf
+ 11;
16260 char *osalt_pos
= strchr (version_pos
, '*');
16262 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16264 u32 version_len
= osalt_pos
- version_pos
;
16266 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16270 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16272 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16274 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16276 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16278 encryptedVerifier_pos
++;
16280 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16282 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16284 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16286 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16288 encryptedVerifierHash_pos
++;
16290 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16292 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16294 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16296 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16300 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16302 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16304 const uint version
= *version_pos
- 0x30;
16306 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16312 oldoffice01
->version
= version
;
16314 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16315 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16316 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16317 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16319 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16320 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16321 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16322 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16324 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16325 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16326 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16327 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16329 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16330 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16331 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16332 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16334 oldoffice01
->rc4key
[1] = 0;
16335 oldoffice01
->rc4key
[0] = 0;
16337 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16338 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16339 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16340 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16341 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16342 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16343 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16344 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16345 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16346 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16348 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16349 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16355 salt
->salt_len
= 16;
16357 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16358 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16359 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16360 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16362 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16363 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16364 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16365 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16367 // this is a workaround as office produces multiple documents with the same salt
16369 salt
->salt_len
+= 32;
16371 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16372 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16373 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16374 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16375 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16376 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16377 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16378 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16384 digest
[0] = oldoffice01
->rc4key
[0];
16385 digest
[1] = oldoffice01
->rc4key
[1];
16389 return (PARSER_OK
);
16392 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16394 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16396 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16398 u32
*digest
= (u32
*) hash_buf
->digest
;
16400 salt_t
*salt
= hash_buf
->salt
;
16402 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16408 char *version_pos
= input_buf
+ 11;
16410 char *osalt_pos
= strchr (version_pos
, '*');
16412 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16414 u32 version_len
= osalt_pos
- version_pos
;
16416 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16420 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16422 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16424 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16426 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16428 encryptedVerifier_pos
++;
16430 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16432 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16434 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16436 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16438 encryptedVerifierHash_pos
++;
16440 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16442 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16444 const uint version
= *version_pos
- 0x30;
16446 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16452 oldoffice34
->version
= version
;
16454 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16455 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16456 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16457 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16459 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16460 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16461 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16462 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16464 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16465 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16466 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16467 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16468 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16470 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16471 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16472 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16473 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16474 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16480 salt
->salt_len
= 16;
16482 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16483 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16484 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16485 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16487 // this is a workaround as office produces multiple documents with the same salt
16489 salt
->salt_len
+= 32;
16491 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16492 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16493 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16494 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16495 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16496 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16497 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16498 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16504 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16505 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16506 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16507 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16509 return (PARSER_OK
);
16512 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16514 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16516 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16519 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16521 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16523 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16525 u32
*digest
= (u32
*) hash_buf
->digest
;
16527 salt_t
*salt
= hash_buf
->salt
;
16529 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16535 char *version_pos
= input_buf
+ 11;
16537 char *osalt_pos
= strchr (version_pos
, '*');
16539 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16541 u32 version_len
= osalt_pos
- version_pos
;
16543 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16547 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16549 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16553 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16555 encryptedVerifier_pos
++;
16557 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16559 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16561 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16563 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16565 encryptedVerifierHash_pos
++;
16567 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16569 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16571 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16573 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16577 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16579 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16581 const uint version
= *version_pos
- 0x30;
16583 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16589 oldoffice34
->version
= version
;
16591 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16592 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16593 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16594 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16596 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16597 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16598 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16599 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16601 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16602 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16603 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16604 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16605 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16607 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16608 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16609 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16610 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16611 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16613 oldoffice34
->rc4key
[1] = 0;
16614 oldoffice34
->rc4key
[0] = 0;
16616 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16617 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16618 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16619 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16620 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16621 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16622 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16623 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16624 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16625 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16627 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16628 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16634 salt
->salt_len
= 16;
16636 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16637 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16638 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16639 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16641 // this is a workaround as office produces multiple documents with the same salt
16643 salt
->salt_len
+= 32;
16645 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16646 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16647 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16648 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16649 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16650 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16651 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16652 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16658 digest
[0] = oldoffice34
->rc4key
[0];
16659 digest
[1] = oldoffice34
->rc4key
[1];
16663 return (PARSER_OK
);
16666 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16668 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16670 u32
*digest
= (u32
*) hash_buf
->digest
;
16672 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16673 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16674 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16675 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16677 digest
[0] = byte_swap_32 (digest
[0]);
16678 digest
[1] = byte_swap_32 (digest
[1]);
16679 digest
[2] = byte_swap_32 (digest
[2]);
16680 digest
[3] = byte_swap_32 (digest
[3]);
16682 return (PARSER_OK
);
16685 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16687 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16689 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16691 u32
*digest
= (u32
*) hash_buf
->digest
;
16693 salt_t
*salt
= hash_buf
->salt
;
16695 char *signature_pos
= input_buf
;
16697 char *salt_pos
= strchr (signature_pos
, '$');
16699 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16701 u32 signature_len
= salt_pos
- signature_pos
;
16703 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16707 char *hash_pos
= strchr (salt_pos
, '$');
16709 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16711 u32 salt_len
= hash_pos
- salt_pos
;
16713 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16717 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16719 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16721 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16722 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16723 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16724 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16725 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16727 digest
[0] -= SHA1M_A
;
16728 digest
[1] -= SHA1M_B
;
16729 digest
[2] -= SHA1M_C
;
16730 digest
[3] -= SHA1M_D
;
16731 digest
[4] -= SHA1M_E
;
16733 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16735 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16737 salt
->salt_len
= salt_len
;
16739 return (PARSER_OK
);
16742 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16744 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16746 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16748 u32
*digest
= (u32
*) hash_buf
->digest
;
16750 salt_t
*salt
= hash_buf
->salt
;
16752 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16758 char *iter_pos
= input_buf
+ 14;
16760 const int iter
= atoi (iter_pos
);
16762 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16764 salt
->salt_iter
= iter
- 1;
16766 char *salt_pos
= strchr (iter_pos
, '$');
16768 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16772 char *hash_pos
= strchr (salt_pos
, '$');
16774 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16776 const uint salt_len
= hash_pos
- salt_pos
;
16780 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16782 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16784 salt
->salt_len
= salt_len
;
16786 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16787 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16789 // add some stuff to normal salt to make sorted happy
16791 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16792 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16793 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16794 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16795 salt
->salt_buf
[4] = salt
->salt_iter
;
16797 // base64 decode hash
16799 u8 tmp_buf
[100] = { 0 };
16801 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16803 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16805 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16807 memcpy (digest
, tmp_buf
, 32);
16809 digest
[0] = byte_swap_32 (digest
[0]);
16810 digest
[1] = byte_swap_32 (digest
[1]);
16811 digest
[2] = byte_swap_32 (digest
[2]);
16812 digest
[3] = byte_swap_32 (digest
[3]);
16813 digest
[4] = byte_swap_32 (digest
[4]);
16814 digest
[5] = byte_swap_32 (digest
[5]);
16815 digest
[6] = byte_swap_32 (digest
[6]);
16816 digest
[7] = byte_swap_32 (digest
[7]);
16818 return (PARSER_OK
);
16821 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16823 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16825 u32
*digest
= (u32
*) hash_buf
->digest
;
16827 salt_t
*salt
= hash_buf
->salt
;
16829 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16830 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16834 digest
[0] = byte_swap_32 (digest
[0]);
16835 digest
[1] = byte_swap_32 (digest
[1]);
16837 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16838 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16839 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16841 char iter_c
= input_buf
[17];
16842 char iter_d
= input_buf
[19];
16844 // atm only defaults, let's see if there's more request
16845 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16846 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16848 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16850 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16851 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16852 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16853 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16855 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16856 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16857 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16858 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16860 salt
->salt_len
= 16;
16862 return (PARSER_OK
);
16865 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16867 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16869 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16871 u32
*digest
= (u32
*) hash_buf
->digest
;
16873 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16875 salt_t
*salt
= hash_buf
->salt
;
16877 char *salt_pos
= input_buf
+ 10;
16879 char *hash_pos
= strchr (salt_pos
, '$');
16881 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16883 uint salt_len
= hash_pos
- salt_pos
;
16887 uint hash_len
= input_len
- 10 - salt_len
- 1;
16889 // base64 decode salt
16891 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16893 u8 tmp_buf
[100] = { 0 };
16895 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16897 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16899 tmp_buf
[salt_len
] = 0x80;
16901 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16903 salt
->salt_len
= salt_len
;
16905 // base64 decode hash
16907 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16909 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16911 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16913 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16915 uint user_len
= hash_len
- 32;
16917 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16919 user_len
--; // skip the trailing space
16921 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16922 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16923 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16924 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16926 digest
[0] = byte_swap_32 (digest
[0]);
16927 digest
[1] = byte_swap_32 (digest
[1]);
16928 digest
[2] = byte_swap_32 (digest
[2]);
16929 digest
[3] = byte_swap_32 (digest
[3]);
16931 // store username for host only (output hash if cracked)
16933 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16934 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16936 return (PARSER_OK
);
16939 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16941 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16943 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16945 u32
*digest
= (u32
*) hash_buf
->digest
;
16947 salt_t
*salt
= hash_buf
->salt
;
16949 char *iter_pos
= input_buf
+ 10;
16951 u32 iter
= atoi (iter_pos
);
16955 return (PARSER_SALT_ITERATION
);
16958 iter
--; // first iteration is special
16960 salt
->salt_iter
= iter
;
16962 char *base64_pos
= strchr (iter_pos
, '}');
16964 if (base64_pos
== NULL
)
16966 return (PARSER_SIGNATURE_UNMATCHED
);
16971 // base64 decode salt
16973 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16975 u8 tmp_buf
[100] = { 0 };
16977 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16979 if (decoded_len
< 24)
16981 return (PARSER_SALT_LENGTH
);
16986 uint salt_len
= decoded_len
- 20;
16988 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16989 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16991 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16993 salt
->salt_len
= salt_len
;
16997 u32
*digest_ptr
= (u32
*) tmp_buf
;
16999 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17000 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17001 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17002 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17003 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17005 return (PARSER_OK
);
17008 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17010 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17012 u32
*digest
= (u32
*) hash_buf
->digest
;
17014 salt_t
*salt
= hash_buf
->salt
;
17016 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17017 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17018 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17019 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17020 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17022 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17024 uint salt_len
= input_len
- 40 - 1;
17026 char *salt_buf
= input_buf
+ 40 + 1;
17028 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17030 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17032 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17034 salt
->salt_len
= salt_len
;
17036 return (PARSER_OK
);
17039 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17041 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17043 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17045 u32
*digest
= (u32
*) hash_buf
->digest
;
17047 salt_t
*salt
= hash_buf
->salt
;
17049 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17055 char *V_pos
= input_buf
+ 5;
17057 char *R_pos
= strchr (V_pos
, '*');
17059 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17061 u32 V_len
= R_pos
- V_pos
;
17065 char *bits_pos
= strchr (R_pos
, '*');
17067 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17069 u32 R_len
= bits_pos
- R_pos
;
17073 char *P_pos
= strchr (bits_pos
, '*');
17075 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17077 u32 bits_len
= P_pos
- bits_pos
;
17081 char *enc_md_pos
= strchr (P_pos
, '*');
17083 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17085 u32 P_len
= enc_md_pos
- P_pos
;
17089 char *id_len_pos
= strchr (enc_md_pos
, '*');
17091 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17093 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17097 char *id_buf_pos
= strchr (id_len_pos
, '*');
17099 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17101 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17105 char *u_len_pos
= strchr (id_buf_pos
, '*');
17107 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17109 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17111 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17115 char *u_buf_pos
= strchr (u_len_pos
, '*');
17117 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17119 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17123 char *o_len_pos
= strchr (u_buf_pos
, '*');
17125 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17127 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17129 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17133 char *o_buf_pos
= strchr (o_len_pos
, '*');
17135 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17137 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17141 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;
17143 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17147 const int V
= atoi (V_pos
);
17148 const int R
= atoi (R_pos
);
17149 const int P
= atoi (P_pos
);
17151 if (V
!= 1) return (PARSER_SALT_VALUE
);
17152 if (R
!= 2) return (PARSER_SALT_VALUE
);
17154 const int enc_md
= atoi (enc_md_pos
);
17156 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17158 const int id_len
= atoi (id_len_pos
);
17159 const int u_len
= atoi (u_len_pos
);
17160 const int o_len
= atoi (o_len_pos
);
17162 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17163 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17164 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17166 const int bits
= atoi (bits_pos
);
17168 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17170 // copy data to esalt
17176 pdf
->enc_md
= enc_md
;
17178 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17179 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17180 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17181 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17182 pdf
->id_len
= id_len
;
17184 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17185 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17186 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17187 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17188 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17189 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17190 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17191 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17192 pdf
->u_len
= u_len
;
17194 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17195 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17196 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17197 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17198 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17199 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17200 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17201 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17202 pdf
->o_len
= o_len
;
17204 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17205 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17206 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17207 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17209 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17210 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17211 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17212 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17213 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17214 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17215 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17216 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17218 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17219 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17220 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17221 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17222 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17223 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17224 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17225 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17227 // we use ID for salt, maybe needs to change, we will see...
17229 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17230 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17231 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17232 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17233 salt
->salt_len
= pdf
->id_len
;
17235 digest
[0] = pdf
->u_buf
[0];
17236 digest
[1] = pdf
->u_buf
[1];
17237 digest
[2] = pdf
->u_buf
[2];
17238 digest
[3] = pdf
->u_buf
[3];
17240 return (PARSER_OK
);
17243 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17245 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17248 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17250 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17252 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17254 u32
*digest
= (u32
*) hash_buf
->digest
;
17256 salt_t
*salt
= hash_buf
->salt
;
17258 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17264 char *V_pos
= input_buf
+ 5;
17266 char *R_pos
= strchr (V_pos
, '*');
17268 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17270 u32 V_len
= R_pos
- V_pos
;
17274 char *bits_pos
= strchr (R_pos
, '*');
17276 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17278 u32 R_len
= bits_pos
- R_pos
;
17282 char *P_pos
= strchr (bits_pos
, '*');
17284 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17286 u32 bits_len
= P_pos
- bits_pos
;
17290 char *enc_md_pos
= strchr (P_pos
, '*');
17292 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17294 u32 P_len
= enc_md_pos
- P_pos
;
17298 char *id_len_pos
= strchr (enc_md_pos
, '*');
17300 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17306 char *id_buf_pos
= strchr (id_len_pos
, '*');
17308 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17314 char *u_len_pos
= strchr (id_buf_pos
, '*');
17316 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17318 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17320 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17324 char *u_buf_pos
= strchr (u_len_pos
, '*');
17326 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17332 char *o_len_pos
= strchr (u_buf_pos
, '*');
17334 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17336 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17338 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17342 char *o_buf_pos
= strchr (o_len_pos
, '*');
17344 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17346 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17350 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17352 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17354 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17356 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17360 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;
17362 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17366 const int V
= atoi (V_pos
);
17367 const int R
= atoi (R_pos
);
17368 const int P
= atoi (P_pos
);
17370 if (V
!= 1) return (PARSER_SALT_VALUE
);
17371 if (R
!= 2) return (PARSER_SALT_VALUE
);
17373 const int enc_md
= atoi (enc_md_pos
);
17375 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17377 const int id_len
= atoi (id_len_pos
);
17378 const int u_len
= atoi (u_len_pos
);
17379 const int o_len
= atoi (o_len_pos
);
17381 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17382 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17383 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17385 const int bits
= atoi (bits_pos
);
17387 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17389 // copy data to esalt
17395 pdf
->enc_md
= enc_md
;
17397 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17398 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17399 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17400 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17401 pdf
->id_len
= id_len
;
17403 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17404 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17405 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17406 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17407 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17408 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17409 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17410 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17411 pdf
->u_len
= u_len
;
17413 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17414 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17415 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17416 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17417 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17418 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17419 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17420 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17421 pdf
->o_len
= o_len
;
17423 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17424 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17425 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17426 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17428 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17429 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17430 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17431 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17432 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17433 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17434 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17435 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17437 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17438 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17439 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17440 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17441 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17442 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17443 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17444 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17446 pdf
->rc4key
[1] = 0;
17447 pdf
->rc4key
[0] = 0;
17449 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17450 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17451 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17452 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17453 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17454 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17455 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17456 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17457 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17458 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17460 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17461 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17463 // we use ID for salt, maybe needs to change, we will see...
17465 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17466 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17467 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17468 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17469 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17470 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17471 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17472 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17473 salt
->salt_len
= pdf
->id_len
+ 16;
17475 digest
[0] = pdf
->rc4key
[0];
17476 digest
[1] = pdf
->rc4key
[1];
17480 return (PARSER_OK
);
17483 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17485 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17487 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17489 u32
*digest
= (u32
*) hash_buf
->digest
;
17491 salt_t
*salt
= hash_buf
->salt
;
17493 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17499 char *V_pos
= input_buf
+ 5;
17501 char *R_pos
= strchr (V_pos
, '*');
17503 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17505 u32 V_len
= R_pos
- V_pos
;
17509 char *bits_pos
= strchr (R_pos
, '*');
17511 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17513 u32 R_len
= bits_pos
- R_pos
;
17517 char *P_pos
= strchr (bits_pos
, '*');
17519 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17521 u32 bits_len
= P_pos
- bits_pos
;
17525 char *enc_md_pos
= strchr (P_pos
, '*');
17527 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17529 u32 P_len
= enc_md_pos
- P_pos
;
17533 char *id_len_pos
= strchr (enc_md_pos
, '*');
17535 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17537 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17541 char *id_buf_pos
= strchr (id_len_pos
, '*');
17543 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17545 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17549 char *u_len_pos
= strchr (id_buf_pos
, '*');
17551 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17553 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17555 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17559 char *u_buf_pos
= strchr (u_len_pos
, '*');
17561 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17563 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17567 char *o_len_pos
= strchr (u_buf_pos
, '*');
17569 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17571 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17573 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17577 char *o_buf_pos
= strchr (o_len_pos
, '*');
17579 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17585 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;
17587 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17591 const int V
= atoi (V_pos
);
17592 const int R
= atoi (R_pos
);
17593 const int P
= atoi (P_pos
);
17597 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17598 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17600 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17602 const int id_len
= atoi (id_len_pos
);
17603 const int u_len
= atoi (u_len_pos
);
17604 const int o_len
= atoi (o_len_pos
);
17606 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17608 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17609 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17611 const int bits
= atoi (bits_pos
);
17613 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17619 enc_md
= atoi (enc_md_pos
);
17622 // copy data to esalt
17628 pdf
->enc_md
= enc_md
;
17630 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17631 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17632 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17633 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17637 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17638 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17639 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17640 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17643 pdf
->id_len
= id_len
;
17645 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17646 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17647 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17648 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17649 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17650 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17651 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17652 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17653 pdf
->u_len
= u_len
;
17655 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17656 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17657 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17658 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17659 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17660 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17661 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17662 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17663 pdf
->o_len
= o_len
;
17665 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17666 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17667 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17668 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17672 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17673 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17674 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17675 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17678 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17679 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17680 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17681 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17682 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17683 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17684 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17685 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17687 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17688 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17689 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17690 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17691 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17692 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17693 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17694 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17696 // precompute rc4 data for later use
17712 uint salt_pc_block
[32] = { 0 };
17714 char *salt_pc_ptr
= (char *) salt_pc_block
;
17716 memcpy (salt_pc_ptr
, padding
, 32);
17717 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17719 uint salt_pc_digest
[4] = { 0 };
17721 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17723 pdf
->rc4data
[0] = salt_pc_digest
[0];
17724 pdf
->rc4data
[1] = salt_pc_digest
[1];
17726 // we use ID for salt, maybe needs to change, we will see...
17728 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17729 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17730 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17731 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17732 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17733 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17734 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17735 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17736 salt
->salt_len
= pdf
->id_len
+ 16;
17738 salt
->salt_iter
= ROUNDS_PDF14
;
17740 digest
[0] = pdf
->u_buf
[0];
17741 digest
[1] = pdf
->u_buf
[1];
17745 return (PARSER_OK
);
17748 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17750 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17752 if (ret
!= PARSER_OK
)
17757 u32
*digest
= (u32
*) hash_buf
->digest
;
17759 salt_t
*salt
= hash_buf
->salt
;
17761 digest
[0] -= SHA256M_A
;
17762 digest
[1] -= SHA256M_B
;
17763 digest
[2] -= SHA256M_C
;
17764 digest
[3] -= SHA256M_D
;
17765 digest
[4] -= SHA256M_E
;
17766 digest
[5] -= SHA256M_F
;
17767 digest
[6] -= SHA256M_G
;
17768 digest
[7] -= SHA256M_H
;
17770 salt
->salt_buf
[2] = 0x80;
17772 return (PARSER_OK
);
17775 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17777 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17779 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17781 u32
*digest
= (u32
*) hash_buf
->digest
;
17783 salt_t
*salt
= hash_buf
->salt
;
17785 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17791 char *V_pos
= input_buf
+ 5;
17793 char *R_pos
= strchr (V_pos
, '*');
17795 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17797 u32 V_len
= R_pos
- V_pos
;
17801 char *bits_pos
= strchr (R_pos
, '*');
17803 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17805 u32 R_len
= bits_pos
- R_pos
;
17809 char *P_pos
= strchr (bits_pos
, '*');
17811 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17813 u32 bits_len
= P_pos
- bits_pos
;
17817 char *enc_md_pos
= strchr (P_pos
, '*');
17819 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17821 u32 P_len
= enc_md_pos
- P_pos
;
17825 char *id_len_pos
= strchr (enc_md_pos
, '*');
17827 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17829 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17833 char *id_buf_pos
= strchr (id_len_pos
, '*');
17835 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17837 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17841 char *u_len_pos
= strchr (id_buf_pos
, '*');
17843 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17845 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17849 char *u_buf_pos
= strchr (u_len_pos
, '*');
17851 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17853 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17857 char *o_len_pos
= strchr (u_buf_pos
, '*');
17859 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17861 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17865 char *o_buf_pos
= strchr (o_len_pos
, '*');
17867 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17869 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17873 char *last
= strchr (o_buf_pos
, '*');
17875 if (last
== NULL
) last
= input_buf
+ input_len
;
17877 u32 o_buf_len
= last
- o_buf_pos
;
17881 const int V
= atoi (V_pos
);
17882 const int R
= atoi (R_pos
);
17886 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17887 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17889 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17891 const int bits
= atoi (bits_pos
);
17893 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17895 int enc_md
= atoi (enc_md_pos
);
17897 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17899 const uint id_len
= atoi (id_len_pos
);
17900 const uint u_len
= atoi (u_len_pos
);
17901 const uint o_len
= atoi (o_len_pos
);
17903 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17904 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17905 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17906 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17907 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17908 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17909 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17910 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17912 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17913 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17914 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17916 // copy data to esalt
17918 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17920 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17922 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17925 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17926 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17928 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17929 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17931 salt
->salt_len
= 8;
17932 salt
->salt_iter
= ROUNDS_PDF17L8
;
17934 digest
[0] = pdf
->u_buf
[0];
17935 digest
[1] = pdf
->u_buf
[1];
17936 digest
[2] = pdf
->u_buf
[2];
17937 digest
[3] = pdf
->u_buf
[3];
17938 digest
[4] = pdf
->u_buf
[4];
17939 digest
[5] = pdf
->u_buf
[5];
17940 digest
[6] = pdf
->u_buf
[6];
17941 digest
[7] = pdf
->u_buf
[7];
17943 return (PARSER_OK
);
17946 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17948 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17950 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17952 u32
*digest
= (u32
*) hash_buf
->digest
;
17954 salt_t
*salt
= hash_buf
->salt
;
17956 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17964 char *iter_pos
= input_buf
+ 7;
17966 u32 iter
= atoi (iter_pos
);
17968 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17969 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17971 // first is *raw* salt
17973 char *salt_pos
= strchr (iter_pos
, ':');
17975 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17979 char *hash_pos
= strchr (salt_pos
, ':');
17981 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17983 u32 salt_len
= hash_pos
- salt_pos
;
17985 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17989 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17991 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17995 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18001 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18002 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18004 salt
->salt_len
= salt_len
;
18005 salt
->salt_iter
= iter
- 1;
18009 u8 tmp_buf
[100] = { 0 };
18011 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18013 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18015 memcpy (digest
, tmp_buf
, 16);
18017 digest
[0] = byte_swap_32 (digest
[0]);
18018 digest
[1] = byte_swap_32 (digest
[1]);
18019 digest
[2] = byte_swap_32 (digest
[2]);
18020 digest
[3] = byte_swap_32 (digest
[3]);
18022 // add some stuff to normal salt to make sorted happy
18024 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18025 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18026 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18027 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18028 salt
->salt_buf
[4] = salt
->salt_iter
;
18030 return (PARSER_OK
);
18033 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18035 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18037 u32
*digest
= (u32
*) hash_buf
->digest
;
18039 salt_t
*salt
= hash_buf
->salt
;
18041 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18042 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18043 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18044 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18046 digest
[0] = byte_swap_32 (digest
[0]);
18047 digest
[1] = byte_swap_32 (digest
[1]);
18048 digest
[2] = byte_swap_32 (digest
[2]);
18049 digest
[3] = byte_swap_32 (digest
[3]);
18051 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18053 uint salt_len
= input_len
- 32 - 1;
18055 char *salt_buf
= input_buf
+ 32 + 1;
18057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18059 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18063 salt
->salt_len
= salt_len
;
18065 return (PARSER_OK
);
18068 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18070 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18072 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18074 u32
*digest
= (u32
*) hash_buf
->digest
;
18076 salt_t
*salt
= hash_buf
->salt
;
18078 char *user_pos
= input_buf
+ 10;
18080 char *salt_pos
= strchr (user_pos
, '*');
18082 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18086 char *hash_pos
= strchr (salt_pos
, '*');
18090 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18092 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18094 uint user_len
= salt_pos
- user_pos
- 1;
18096 uint salt_len
= hash_pos
- salt_pos
- 1;
18098 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18104 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18105 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18106 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18107 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18109 digest
[0] = byte_swap_32 (digest
[0]);
18110 digest
[1] = byte_swap_32 (digest
[1]);
18111 digest
[2] = byte_swap_32 (digest
[2]);
18112 digest
[3] = byte_swap_32 (digest
[3]);
18114 digest
[0] -= MD5M_A
;
18115 digest
[1] -= MD5M_B
;
18116 digest
[2] -= MD5M_C
;
18117 digest
[3] -= MD5M_D
;
18123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18125 // first 4 bytes are the "challenge"
18127 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18128 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18129 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18130 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18132 // append the user name
18134 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18136 salt
->salt_len
= 4 + user_len
;
18138 return (PARSER_OK
);
18141 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18143 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18145 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18147 u32
*digest
= (u32
*) hash_buf
->digest
;
18149 salt_t
*salt
= hash_buf
->salt
;
18151 char *salt_pos
= input_buf
+ 9;
18153 char *hash_pos
= strchr (salt_pos
, '*');
18155 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18159 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18161 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18163 uint salt_len
= hash_pos
- salt_pos
- 1;
18165 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18171 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18172 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18173 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18174 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18175 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18181 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18183 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18185 salt
->salt_len
= salt_len
;
18187 return (PARSER_OK
);
18190 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18192 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18194 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18196 u32
*digest
= (u32
*) hash_buf
->digest
;
18198 salt_t
*salt
= hash_buf
->salt
;
18200 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18206 char *cry_master_len_pos
= input_buf
+ 9;
18208 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18210 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18212 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18214 cry_master_buf_pos
++;
18216 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18218 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18220 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18222 cry_salt_len_pos
++;
18224 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18226 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18228 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18230 cry_salt_buf_pos
++;
18232 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18234 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18236 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18240 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18242 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18244 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18248 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18250 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18252 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18256 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18258 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18260 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18262 public_key_len_pos
++;
18264 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18266 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18268 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18270 public_key_buf_pos
++;
18272 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;
18274 const uint cry_master_len
= atoi (cry_master_len_pos
);
18275 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18276 const uint ckey_len
= atoi (ckey_len_pos
);
18277 const uint public_key_len
= atoi (public_key_len_pos
);
18279 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18280 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18281 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18282 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18284 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18286 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18288 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18291 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18293 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18295 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18298 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18300 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18302 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18305 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18306 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18307 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18310 * store digest (should be unique enought, hopefully)
18313 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18314 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18315 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18316 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18322 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18324 const uint cry_rounds
= atoi (cry_rounds_pos
);
18326 salt
->salt_iter
= cry_rounds
- 1;
18328 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18330 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18332 salt
->salt_len
= salt_len
;
18334 return (PARSER_OK
);
18337 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18339 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18341 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18343 u32
*digest
= (u32
*) hash_buf
->digest
;
18345 salt_t
*salt
= hash_buf
->salt
;
18347 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18349 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18351 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18353 memcpy (temp_input_buf
, input_buf
, input_len
);
18357 char *URI_server_pos
= temp_input_buf
+ 6;
18359 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18361 if (URI_client_pos
== NULL
)
18363 myfree (temp_input_buf
);
18365 return (PARSER_SEPARATOR_UNMATCHED
);
18368 URI_client_pos
[0] = 0;
18371 uint URI_server_len
= strlen (URI_server_pos
);
18373 if (URI_server_len
> 512)
18375 myfree (temp_input_buf
);
18377 return (PARSER_SALT_LENGTH
);
18382 char *user_pos
= strchr (URI_client_pos
, '*');
18384 if (user_pos
== NULL
)
18386 myfree (temp_input_buf
);
18388 return (PARSER_SEPARATOR_UNMATCHED
);
18394 uint URI_client_len
= strlen (URI_client_pos
);
18396 if (URI_client_len
> 512)
18398 myfree (temp_input_buf
);
18400 return (PARSER_SALT_LENGTH
);
18405 char *realm_pos
= strchr (user_pos
, '*');
18407 if (realm_pos
== NULL
)
18409 myfree (temp_input_buf
);
18411 return (PARSER_SEPARATOR_UNMATCHED
);
18417 uint user_len
= strlen (user_pos
);
18419 if (user_len
> 116)
18421 myfree (temp_input_buf
);
18423 return (PARSER_SALT_LENGTH
);
18428 char *method_pos
= strchr (realm_pos
, '*');
18430 if (method_pos
== NULL
)
18432 myfree (temp_input_buf
);
18434 return (PARSER_SEPARATOR_UNMATCHED
);
18440 uint realm_len
= strlen (realm_pos
);
18442 if (realm_len
> 116)
18444 myfree (temp_input_buf
);
18446 return (PARSER_SALT_LENGTH
);
18451 char *URI_prefix_pos
= strchr (method_pos
, '*');
18453 if (URI_prefix_pos
== NULL
)
18455 myfree (temp_input_buf
);
18457 return (PARSER_SEPARATOR_UNMATCHED
);
18460 URI_prefix_pos
[0] = 0;
18463 uint method_len
= strlen (method_pos
);
18465 if (method_len
> 246)
18467 myfree (temp_input_buf
);
18469 return (PARSER_SALT_LENGTH
);
18474 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18476 if (URI_resource_pos
== NULL
)
18478 myfree (temp_input_buf
);
18480 return (PARSER_SEPARATOR_UNMATCHED
);
18483 URI_resource_pos
[0] = 0;
18484 URI_resource_pos
++;
18486 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18488 if (URI_prefix_len
> 245)
18490 myfree (temp_input_buf
);
18492 return (PARSER_SALT_LENGTH
);
18497 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18499 if (URI_suffix_pos
== NULL
)
18501 myfree (temp_input_buf
);
18503 return (PARSER_SEPARATOR_UNMATCHED
);
18506 URI_suffix_pos
[0] = 0;
18509 uint URI_resource_len
= strlen (URI_resource_pos
);
18511 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18513 myfree (temp_input_buf
);
18515 return (PARSER_SALT_LENGTH
);
18520 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18522 if (nonce_pos
== NULL
)
18524 myfree (temp_input_buf
);
18526 return (PARSER_SEPARATOR_UNMATCHED
);
18532 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18534 if (URI_suffix_len
> 245)
18536 myfree (temp_input_buf
);
18538 return (PARSER_SALT_LENGTH
);
18543 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18545 if (nonce_client_pos
== NULL
)
18547 myfree (temp_input_buf
);
18549 return (PARSER_SEPARATOR_UNMATCHED
);
18552 nonce_client_pos
[0] = 0;
18553 nonce_client_pos
++;
18555 uint nonce_len
= strlen (nonce_pos
);
18557 if (nonce_len
< 1 || nonce_len
> 50)
18559 myfree (temp_input_buf
);
18561 return (PARSER_SALT_LENGTH
);
18566 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18568 if (nonce_count_pos
== NULL
)
18570 myfree (temp_input_buf
);
18572 return (PARSER_SEPARATOR_UNMATCHED
);
18575 nonce_count_pos
[0] = 0;
18578 uint nonce_client_len
= strlen (nonce_client_pos
);
18580 if (nonce_client_len
> 50)
18582 myfree (temp_input_buf
);
18584 return (PARSER_SALT_LENGTH
);
18589 char *qop_pos
= strchr (nonce_count_pos
, '*');
18591 if (qop_pos
== NULL
)
18593 myfree (temp_input_buf
);
18595 return (PARSER_SEPARATOR_UNMATCHED
);
18601 uint nonce_count_len
= strlen (nonce_count_pos
);
18603 if (nonce_count_len
> 50)
18605 myfree (temp_input_buf
);
18607 return (PARSER_SALT_LENGTH
);
18612 char *directive_pos
= strchr (qop_pos
, '*');
18614 if (directive_pos
== NULL
)
18616 myfree (temp_input_buf
);
18618 return (PARSER_SEPARATOR_UNMATCHED
);
18621 directive_pos
[0] = 0;
18624 uint qop_len
= strlen (qop_pos
);
18628 myfree (temp_input_buf
);
18630 return (PARSER_SALT_LENGTH
);
18635 char *digest_pos
= strchr (directive_pos
, '*');
18637 if (digest_pos
== NULL
)
18639 myfree (temp_input_buf
);
18641 return (PARSER_SEPARATOR_UNMATCHED
);
18647 uint directive_len
= strlen (directive_pos
);
18649 if (directive_len
!= 3)
18651 myfree (temp_input_buf
);
18653 return (PARSER_SALT_LENGTH
);
18656 if (memcmp (directive_pos
, "MD5", 3))
18658 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18660 myfree (temp_input_buf
);
18662 return (PARSER_SIP_AUTH_DIRECTIVE
);
18666 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18671 uint md5_max_len
= 4 * 64;
18673 uint md5_remaining_len
= md5_max_len
;
18675 uint tmp_md5_buf
[64] = { 0 };
18677 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18679 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18681 md5_len
+= method_len
+ 1;
18682 tmp_md5_ptr
+= method_len
+ 1;
18684 if (URI_prefix_len
> 0)
18686 md5_remaining_len
= md5_max_len
- md5_len
;
18688 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18690 md5_len
+= URI_prefix_len
+ 1;
18691 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18694 md5_remaining_len
= md5_max_len
- md5_len
;
18696 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18698 md5_len
+= URI_resource_len
;
18699 tmp_md5_ptr
+= URI_resource_len
;
18701 if (URI_suffix_len
> 0)
18703 md5_remaining_len
= md5_max_len
- md5_len
;
18705 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18707 md5_len
+= 1 + URI_suffix_len
;
18710 uint tmp_digest
[4] = { 0 };
18712 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18714 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18715 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18716 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18717 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18723 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18725 uint esalt_len
= 0;
18727 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18729 // there are 2 possibilities for the esalt:
18731 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18733 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18735 if (esalt_len
> max_esalt_len
)
18737 myfree (temp_input_buf
);
18739 return (PARSER_SALT_LENGTH
);
18742 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18754 esalt_len
= 1 + nonce_len
+ 1 + 32;
18756 if (esalt_len
> max_esalt_len
)
18758 myfree (temp_input_buf
);
18760 return (PARSER_SALT_LENGTH
);
18763 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18771 // add 0x80 to esalt
18773 esalt_buf_ptr
[esalt_len
] = 0x80;
18775 sip
->esalt_len
= esalt_len
;
18781 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18783 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18785 uint max_salt_len
= 119;
18787 if (salt_len
> max_salt_len
)
18789 myfree (temp_input_buf
);
18791 return (PARSER_SALT_LENGTH
);
18794 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18796 sip
->salt_len
= salt_len
;
18799 * fake salt (for sorting)
18802 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18806 uint fake_salt_len
= salt_len
;
18808 if (fake_salt_len
> max_salt_len
)
18810 fake_salt_len
= max_salt_len
;
18813 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18815 salt
->salt_len
= fake_salt_len
;
18821 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18822 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18823 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18824 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18826 digest
[0] = byte_swap_32 (digest
[0]);
18827 digest
[1] = byte_swap_32 (digest
[1]);
18828 digest
[2] = byte_swap_32 (digest
[2]);
18829 digest
[3] = byte_swap_32 (digest
[3]);
18831 myfree (temp_input_buf
);
18833 return (PARSER_OK
);
18836 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18838 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18840 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18842 u32
*digest
= (u32
*) hash_buf
->digest
;
18844 salt_t
*salt
= hash_buf
->salt
;
18848 char *digest_pos
= input_buf
;
18850 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18857 char *salt_buf
= input_buf
+ 8 + 1;
18861 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18863 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18867 salt
->salt_len
= salt_len
;
18869 return (PARSER_OK
);
18872 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18874 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18876 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18878 u32
*digest
= (u32
*) hash_buf
->digest
;
18880 salt_t
*salt
= hash_buf
->salt
;
18882 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18888 char *p_buf_pos
= input_buf
+ 4;
18890 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18892 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18894 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18896 NumCyclesPower_pos
++;
18898 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18900 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18902 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18906 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18908 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18910 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18914 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18916 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18918 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18922 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18924 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18926 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18930 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18932 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18934 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18938 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18940 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18942 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18946 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18948 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18950 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18954 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18956 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18958 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18962 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;
18964 const uint iter
= atoi (NumCyclesPower_pos
);
18965 const uint crc
= atoi (crc_buf_pos
);
18966 const uint p_buf
= atoi (p_buf_pos
);
18967 const uint salt_len
= atoi (salt_len_pos
);
18968 const uint iv_len
= atoi (iv_len_pos
);
18969 const uint unpack_size
= atoi (unpack_size_pos
);
18970 const uint data_len
= atoi (data_len_pos
);
18976 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18977 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18979 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18981 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18983 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18989 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18990 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18991 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18992 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18994 seven_zip
->iv_len
= iv_len
;
18996 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18998 seven_zip
->salt_len
= 0;
19000 seven_zip
->crc
= crc
;
19002 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19004 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19006 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19009 seven_zip
->data_len
= data_len
;
19011 seven_zip
->unpack_size
= unpack_size
;
19015 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19016 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19017 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19018 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19020 salt
->salt_len
= 16;
19022 salt
->salt_sign
[0] = iter
;
19024 salt
->salt_iter
= 1 << iter
;
19035 return (PARSER_OK
);
19038 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19040 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19042 u32
*digest
= (u32
*) hash_buf
->digest
;
19044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19048 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19049 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19050 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19051 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19053 digest
[0] = byte_swap_32 (digest
[0]);
19054 digest
[1] = byte_swap_32 (digest
[1]);
19055 digest
[2] = byte_swap_32 (digest
[2]);
19056 digest
[3] = byte_swap_32 (digest
[3]);
19057 digest
[4] = byte_swap_32 (digest
[4]);
19058 digest
[5] = byte_swap_32 (digest
[5]);
19059 digest
[6] = byte_swap_32 (digest
[6]);
19060 digest
[7] = byte_swap_32 (digest
[7]);
19062 return (PARSER_OK
);
19065 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19067 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19069 u32
*digest
= (u32
*) hash_buf
->digest
;
19071 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19072 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19073 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19074 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19075 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19076 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19077 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19078 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19079 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19080 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19081 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19082 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19083 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19084 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19085 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19086 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19088 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19089 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19090 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19091 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19092 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19093 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19094 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19095 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19096 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19097 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19098 digest
[10] = byte_swap_32 (digest
[10]);
19099 digest
[11] = byte_swap_32 (digest
[11]);
19100 digest
[12] = byte_swap_32 (digest
[12]);
19101 digest
[13] = byte_swap_32 (digest
[13]);
19102 digest
[14] = byte_swap_32 (digest
[14]);
19103 digest
[15] = byte_swap_32 (digest
[15]);
19105 return (PARSER_OK
);
19108 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19110 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19112 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19114 u32
*digest
= (u32
*) hash_buf
->digest
;
19116 salt_t
*salt
= hash_buf
->salt
;
19118 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19126 char *iter_pos
= input_buf
+ 4;
19128 u32 iter
= atoi (iter_pos
);
19130 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19131 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19133 // first is *raw* salt
19135 char *salt_pos
= strchr (iter_pos
, ':');
19137 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19141 char *hash_pos
= strchr (salt_pos
, ':');
19143 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19145 u32 salt_len
= hash_pos
- salt_pos
;
19147 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19151 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19153 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19157 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19159 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19161 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19163 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19164 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19166 salt
->salt_len
= salt_len
;
19167 salt
->salt_iter
= iter
- 1;
19171 u8 tmp_buf
[100] = { 0 };
19173 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19175 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19177 memcpy (digest
, tmp_buf
, 16);
19179 // add some stuff to normal salt to make sorted happy
19181 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19182 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19183 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19184 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19185 salt
->salt_buf
[4] = salt
->salt_iter
;
19187 return (PARSER_OK
);
19190 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19192 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19194 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19196 u32
*digest
= (u32
*) hash_buf
->digest
;
19198 salt_t
*salt
= hash_buf
->salt
;
19200 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19208 char *iter_pos
= input_buf
+ 5;
19210 u32 iter
= atoi (iter_pos
);
19212 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19213 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19215 // first is *raw* salt
19217 char *salt_pos
= strchr (iter_pos
, ':');
19219 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19223 char *hash_pos
= strchr (salt_pos
, ':');
19225 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19227 u32 salt_len
= hash_pos
- salt_pos
;
19229 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19233 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19235 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19239 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19241 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19243 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19245 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19246 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19248 salt
->salt_len
= salt_len
;
19249 salt
->salt_iter
= iter
- 1;
19253 u8 tmp_buf
[100] = { 0 };
19255 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19257 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19259 memcpy (digest
, tmp_buf
, 16);
19261 digest
[0] = byte_swap_32 (digest
[0]);
19262 digest
[1] = byte_swap_32 (digest
[1]);
19263 digest
[2] = byte_swap_32 (digest
[2]);
19264 digest
[3] = byte_swap_32 (digest
[3]);
19266 // add some stuff to normal salt to make sorted happy
19268 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19269 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19270 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19271 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19272 salt
->salt_buf
[4] = salt
->salt_iter
;
19274 return (PARSER_OK
);
19277 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19279 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19281 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19283 u64
*digest
= (u64
*) hash_buf
->digest
;
19285 salt_t
*salt
= hash_buf
->salt
;
19287 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19295 char *iter_pos
= input_buf
+ 7;
19297 u32 iter
= atoi (iter_pos
);
19299 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19300 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19302 // first is *raw* salt
19304 char *salt_pos
= strchr (iter_pos
, ':');
19306 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19310 char *hash_pos
= strchr (salt_pos
, ':');
19312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19314 u32 salt_len
= hash_pos
- salt_pos
;
19316 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19320 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19322 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19326 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19328 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19330 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19332 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19333 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19335 salt
->salt_len
= salt_len
;
19336 salt
->salt_iter
= iter
- 1;
19340 u8 tmp_buf
[100] = { 0 };
19342 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19344 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19346 memcpy (digest
, tmp_buf
, 64);
19348 digest
[0] = byte_swap_64 (digest
[0]);
19349 digest
[1] = byte_swap_64 (digest
[1]);
19350 digest
[2] = byte_swap_64 (digest
[2]);
19351 digest
[3] = byte_swap_64 (digest
[3]);
19352 digest
[4] = byte_swap_64 (digest
[4]);
19353 digest
[5] = byte_swap_64 (digest
[5]);
19354 digest
[6] = byte_swap_64 (digest
[6]);
19355 digest
[7] = byte_swap_64 (digest
[7]);
19357 // add some stuff to normal salt to make sorted happy
19359 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19360 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19361 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19362 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19363 salt
->salt_buf
[4] = salt
->salt_iter
;
19365 return (PARSER_OK
);
19368 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19370 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19372 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19374 uint
*digest
= (uint
*) hash_buf
->digest
;
19376 salt_t
*salt
= hash_buf
->salt
;
19382 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19384 char *hash_pos
= strchr (salt_pos
, '$');
19386 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19388 u32 salt_len
= hash_pos
- salt_pos
;
19390 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19394 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19396 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19400 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19401 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19419 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19420 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19422 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19423 salt
->salt_len
= 8;
19425 return (PARSER_OK
);
19428 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19430 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19432 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19434 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19436 if (c19
& 3) return (PARSER_HASH_VALUE
);
19438 salt_t
*salt
= hash_buf
->salt
;
19440 u32
*digest
= (u32
*) hash_buf
->digest
;
19444 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19445 | itoa64_to_int (input_buf
[2]) << 6
19446 | itoa64_to_int (input_buf
[3]) << 12
19447 | itoa64_to_int (input_buf
[4]) << 18;
19451 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19452 | itoa64_to_int (input_buf
[6]) << 6
19453 | itoa64_to_int (input_buf
[7]) << 12
19454 | itoa64_to_int (input_buf
[8]) << 18;
19456 salt
->salt_len
= 4;
19458 u8 tmp_buf
[100] = { 0 };
19460 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19462 memcpy (digest
, tmp_buf
, 8);
19466 IP (digest
[0], digest
[1], tt
);
19468 digest
[0] = rotr32 (digest
[0], 31);
19469 digest
[1] = rotr32 (digest
[1], 31);
19473 return (PARSER_OK
);
19476 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19478 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19480 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19482 u32
*digest
= (u32
*) hash_buf
->digest
;
19484 salt_t
*salt
= hash_buf
->salt
;
19490 char *type_pos
= input_buf
+ 6 + 1;
19492 char *salt_pos
= strchr (type_pos
, '*');
19494 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19496 u32 type_len
= salt_pos
- type_pos
;
19498 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19502 char *crypted_pos
= strchr (salt_pos
, '*');
19504 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19506 u32 salt_len
= crypted_pos
- salt_pos
;
19508 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19512 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19514 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19520 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19521 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19523 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19524 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19526 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19527 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19528 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19529 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19531 salt
->salt_len
= 24;
19532 salt
->salt_iter
= ROUNDS_RAR3
;
19534 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19535 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19537 digest
[0] = 0xc43d7b00;
19538 digest
[1] = 0x40070000;
19542 return (PARSER_OK
);
19545 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19547 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19549 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19551 u32
*digest
= (u32
*) hash_buf
->digest
;
19553 salt_t
*salt
= hash_buf
->salt
;
19555 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19561 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19563 char *param1_pos
= strchr (param0_pos
, '$');
19565 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19567 u32 param0_len
= param1_pos
- param0_pos
;
19571 char *param2_pos
= strchr (param1_pos
, '$');
19573 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19575 u32 param1_len
= param2_pos
- param1_pos
;
19579 char *param3_pos
= strchr (param2_pos
, '$');
19581 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19583 u32 param2_len
= param3_pos
- param2_pos
;
19587 char *param4_pos
= strchr (param3_pos
, '$');
19589 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19591 u32 param3_len
= param4_pos
- param3_pos
;
19595 char *param5_pos
= strchr (param4_pos
, '$');
19597 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19599 u32 param4_len
= param5_pos
- param4_pos
;
19603 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19605 char *salt_buf
= param1_pos
;
19606 char *iv
= param3_pos
;
19607 char *pswcheck
= param5_pos
;
19609 const uint salt_len
= atoi (param0_pos
);
19610 const uint iterations
= atoi (param2_pos
);
19611 const uint pswcheck_len
= atoi (param4_pos
);
19617 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19618 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19619 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19621 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19622 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19623 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19629 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19630 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19631 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19632 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19634 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19635 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19636 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19637 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19639 salt
->salt_len
= 16;
19641 salt
->salt_sign
[0] = iterations
;
19643 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19649 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19650 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19654 return (PARSER_OK
);
19657 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19659 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19661 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19663 u32
*digest
= (u32
*) hash_buf
->digest
;
19665 salt_t
*salt
= hash_buf
->salt
;
19667 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19674 char *account_pos
= input_buf
+ 11 + 1;
19680 if (account_pos
[0] == '*')
19684 data_pos
= strchr (account_pos
, '*');
19689 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19691 uint account_len
= data_pos
- account_pos
+ 1;
19693 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19698 data_len
= input_len
- 11 - 1 - account_len
- 2;
19700 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19704 /* assume $krb5tgs$23$checksum$edata2 */
19705 data_pos
= account_pos
;
19707 memcpy (krb5tgs
->account_info
, "**", 3);
19709 data_len
= input_len
- 11 - 1 - 1;
19712 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19714 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19716 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19718 const char p0
= data_pos
[i
+ 0];
19719 const char p1
= data_pos
[i
+ 1];
19721 *checksum_ptr
++ = hex_convert (p1
) << 0
19722 | hex_convert (p0
) << 4;
19725 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19727 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19730 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19732 const char p0
= data_pos
[i
+ 0];
19733 const char p1
= data_pos
[i
+ 1];
19734 *edata_ptr
++ = hex_convert (p1
) << 0
19735 | hex_convert (p0
) << 4;
19738 /* this is needed for hmac_md5 */
19739 *edata_ptr
++ = 0x80;
19741 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19742 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19743 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19744 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19746 salt
->salt_len
= 32;
19748 digest
[0] = krb5tgs
->checksum
[0];
19749 digest
[1] = krb5tgs
->checksum
[1];
19750 digest
[2] = krb5tgs
->checksum
[2];
19751 digest
[3] = krb5tgs
->checksum
[3];
19753 return (PARSER_OK
);
19756 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19758 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19760 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19762 u32
*digest
= (u32
*) hash_buf
->digest
;
19764 salt_t
*salt
= hash_buf
->salt
;
19771 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19775 char *wrapped_key_pos
;
19779 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19781 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19783 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19785 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19790 data_pos
= salt_pos
;
19792 wrapped_key_pos
= strchr (salt_pos
, '*');
19794 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19796 uint salt_len
= wrapped_key_pos
- salt_pos
;
19798 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19803 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19805 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19807 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19808 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19809 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19810 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19814 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19815 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19816 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19817 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19818 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19819 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19821 salt
->salt_len
= 40;
19823 digest
[0] = salt
->salt_buf
[0];
19824 digest
[1] = salt
->salt_buf
[1];
19825 digest
[2] = salt
->salt_buf
[2];
19826 digest
[3] = salt
->salt_buf
[3];
19828 return (PARSER_OK
);
19831 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19833 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19835 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19837 u32
*digest
= (u32
*) hash_buf
->digest
;
19839 salt_t
*salt
= hash_buf
->salt
;
19841 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19851 char *algorithm_pos
;
19853 char *final_random_seed_pos
;
19854 u32 final_random_seed_len
;
19856 char *transf_random_seed_pos
;
19857 u32 transf_random_seed_len
;
19862 /* default is no keyfile provided */
19863 char *keyfile_len_pos
;
19864 u32 keyfile_len
= 0;
19865 u32 is_keyfile_present
= 0;
19866 char *keyfile_inline_pos
;
19869 /* specific to version 1 */
19870 char *contents_len_pos
;
19872 char *contents_pos
;
19874 /* specific to version 2 */
19875 char *expected_bytes_pos
;
19876 u32 expected_bytes_len
;
19878 char *contents_hash_pos
;
19879 u32 contents_hash_len
;
19881 version_pos
= input_buf
+ 8 + 1 + 1;
19883 keepass
->version
= atoi (version_pos
);
19885 rounds_pos
= strchr (version_pos
, '*');
19887 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19891 salt
->salt_iter
= (atoi (rounds_pos
));
19893 algorithm_pos
= strchr (rounds_pos
, '*');
19895 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19899 keepass
->algorithm
= atoi (algorithm_pos
);
19901 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19903 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19905 final_random_seed_pos
++;
19907 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19908 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19909 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19910 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19912 if (keepass
->version
== 2)
19914 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19915 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19916 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19917 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19920 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19922 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19924 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19926 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19927 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19929 transf_random_seed_pos
++;
19931 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19932 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19933 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19934 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19935 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19936 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19937 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19938 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19940 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19942 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19944 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19946 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19950 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19951 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19952 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19953 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19955 if (keepass
->version
== 1)
19957 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19959 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19961 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19963 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19965 contents_hash_pos
++;
19967 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19968 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19969 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19970 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19971 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19972 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19973 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19974 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19976 /* get length of contents following */
19977 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19979 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19981 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19983 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19987 u32 inline_flag
= atoi (inline_flag_pos
);
19989 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19991 contents_len_pos
= strchr (inline_flag_pos
, '*');
19993 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19995 contents_len_pos
++;
19997 contents_len
= atoi (contents_len_pos
);
19999 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20001 contents_pos
= strchr (contents_len_pos
, '*');
20003 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20009 keepass
->contents_len
= contents_len
;
20011 contents_len
= contents_len
/ 4;
20013 keyfile_inline_pos
= strchr (contents_pos
, '*');
20015 u32 real_contents_len
;
20017 if (keyfile_inline_pos
== NULL
)
20018 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20021 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20022 keyfile_inline_pos
++;
20023 is_keyfile_present
= 1;
20026 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20028 for (i
= 0; i
< contents_len
; i
++)
20029 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20031 else if (keepass
->version
== 2)
20033 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20035 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20037 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20039 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20041 expected_bytes_pos
++;
20043 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20044 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20045 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20046 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20047 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20048 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20049 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20050 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20052 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20054 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20056 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20058 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20060 contents_hash_pos
++;
20062 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20063 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20064 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20065 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20066 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20067 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20068 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20069 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20071 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20073 if (keyfile_inline_pos
== NULL
)
20074 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20077 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20078 keyfile_inline_pos
++;
20079 is_keyfile_present
= 1;
20081 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20084 if (is_keyfile_present
!= 0)
20086 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20090 keyfile_len
= atoi (keyfile_len_pos
);
20092 keepass
->keyfile_len
= keyfile_len
;
20094 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20096 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20098 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20102 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20104 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20106 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20107 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20108 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20109 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20110 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20111 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20112 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20113 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20116 digest
[0] = keepass
->enc_iv
[0];
20117 digest
[1] = keepass
->enc_iv
[1];
20118 digest
[2] = keepass
->enc_iv
[2];
20119 digest
[3] = keepass
->enc_iv
[3];
20121 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20122 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20123 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20124 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20125 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20126 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20127 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20128 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20130 return (PARSER_OK
);
20133 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20135 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20137 u32
*digest
= (u32
*) hash_buf
->digest
;
20139 salt_t
*salt
= hash_buf
->salt
;
20141 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20142 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20143 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20144 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20145 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20146 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20147 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20148 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20150 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20152 uint salt_len
= input_len
- 64 - 1;
20154 char *salt_buf
= input_buf
+ 64 + 1;
20156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20162 salt
->salt_len
= salt_len
;
20165 * we can precompute the first sha256 transform
20168 uint w
[16] = { 0 };
20170 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20171 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20172 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20173 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20174 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20175 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20176 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20177 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20178 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20179 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20180 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20181 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20182 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20183 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20184 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20185 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20187 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20189 sha256_64 (w
, pc256
);
20191 salt
->salt_buf_pc
[0] = pc256
[0];
20192 salt
->salt_buf_pc
[1] = pc256
[1];
20193 salt
->salt_buf_pc
[2] = pc256
[2];
20194 salt
->salt_buf_pc
[3] = pc256
[3];
20195 salt
->salt_buf_pc
[4] = pc256
[4];
20196 salt
->salt_buf_pc
[5] = pc256
[5];
20197 salt
->salt_buf_pc
[6] = pc256
[6];
20198 salt
->salt_buf_pc
[7] = pc256
[7];
20200 digest
[0] -= pc256
[0];
20201 digest
[1] -= pc256
[1];
20202 digest
[2] -= pc256
[2];
20203 digest
[3] -= pc256
[3];
20204 digest
[4] -= pc256
[4];
20205 digest
[5] -= pc256
[5];
20206 digest
[6] -= pc256
[6];
20207 digest
[7] -= pc256
[7];
20209 return (PARSER_OK
);
20212 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20214 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20216 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20218 u32
*digest
= (u32
*) hash_buf
->digest
;
20220 salt_t
*salt
= hash_buf
->salt
;
20226 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20228 char *data_buf_pos
= strchr (data_len_pos
, '$');
20230 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20232 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20234 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20235 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20239 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20241 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20243 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20245 u32 data_len
= atoi (data_len_pos
);
20247 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20253 char *salt_pos
= data_buf_pos
;
20255 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20256 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20257 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20258 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20260 // this is actually the CT, which is also the hash later (if matched)
20262 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20263 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20264 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20265 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20267 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20269 salt
->salt_iter
= 10 - 1;
20275 digest
[0] = salt
->salt_buf
[4];
20276 digest
[1] = salt
->salt_buf
[5];
20277 digest
[2] = salt
->salt_buf
[6];
20278 digest
[3] = salt
->salt_buf
[7];
20280 return (PARSER_OK
);
20283 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20285 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20287 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20289 u32
*digest
= (u32
*) hash_buf
->digest
;
20291 salt_t
*salt
= hash_buf
->salt
;
20297 char *salt_pos
= input_buf
+ 11 + 1;
20299 char *iter_pos
= strchr (salt_pos
, ',');
20301 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20303 u32 salt_len
= iter_pos
- salt_pos
;
20305 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20309 char *hash_pos
= strchr (iter_pos
, ',');
20311 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20313 u32 iter_len
= hash_pos
- iter_pos
;
20315 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20319 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20321 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20327 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20328 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20329 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20330 salt
->salt_buf
[3] = 0x00018000;
20332 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20333 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20334 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20335 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20337 salt
->salt_len
= salt_len
/ 2;
20339 salt
->salt_iter
= atoi (iter_pos
) - 1;
20345 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20346 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20347 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20348 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20349 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20350 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20351 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20352 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20354 return (PARSER_OK
);
20357 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20359 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20361 u32
*digest
= (u32
*) hash_buf
->digest
;
20363 salt_t
*salt
= hash_buf
->salt
;
20369 char *hash_pos
= input_buf
+ 64;
20370 char *salt1_pos
= input_buf
+ 128;
20371 char *salt2_pos
= input_buf
;
20377 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20378 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20379 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20380 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20382 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20383 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20384 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20385 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20387 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20388 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20389 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20390 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20392 salt
->salt_len
= 48;
20394 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20400 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20401 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20402 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20403 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20404 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20405 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20406 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20407 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20409 return (PARSER_OK
);
20412 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20414 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20416 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20417 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20419 u32
*digest
= (u32
*) hash_buf
->digest
;
20421 salt_t
*salt
= hash_buf
->salt
;
20423 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20429 char *param0_pos
= input_buf
+ 6 + 1;
20431 char *param1_pos
= strchr (param0_pos
, '*');
20433 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20435 u32 param0_len
= param1_pos
- param0_pos
;
20439 char *param2_pos
= strchr (param1_pos
, '*');
20441 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20443 u32 param1_len
= param2_pos
- param1_pos
;
20447 char *param3_pos
= strchr (param2_pos
, '*');
20449 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20451 u32 param2_len
= param3_pos
- param2_pos
;
20455 char *param4_pos
= strchr (param3_pos
, '*');
20457 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20459 u32 param3_len
= param4_pos
- param3_pos
;
20463 char *param5_pos
= strchr (param4_pos
, '*');
20465 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20467 u32 param4_len
= param5_pos
- param4_pos
;
20471 char *param6_pos
= strchr (param5_pos
, '*');
20473 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20475 u32 param5_len
= param6_pos
- param5_pos
;
20479 char *param7_pos
= strchr (param6_pos
, '*');
20481 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20483 u32 param6_len
= param7_pos
- param6_pos
;
20487 char *param8_pos
= strchr (param7_pos
, '*');
20489 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20491 u32 param7_len
= param8_pos
- param7_pos
;
20495 const uint type
= atoi (param0_pos
);
20496 const uint mode
= atoi (param1_pos
);
20497 const uint magic
= atoi (param2_pos
);
20499 char *salt_buf
= param3_pos
;
20501 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20503 const uint compress_length
= atoi (param5_pos
);
20505 char *data_buf
= param6_pos
;
20506 char *auth
= param7_pos
;
20512 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20514 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20516 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20518 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20520 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20522 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20524 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20526 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20528 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20530 if (type
!= 0) return (PARSER_SALT_VALUE
);
20532 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20534 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20536 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20544 zip2
->magic
= magic
;
20548 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20549 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20550 zip2
->salt_buf
[2] = 0;
20551 zip2
->salt_buf
[3] = 0;
20553 zip2
->salt_len
= 8;
20555 else if (mode
== 2)
20557 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20558 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20559 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20560 zip2
->salt_buf
[3] = 0;
20562 zip2
->salt_len
= 12;
20564 else if (mode
== 3)
20566 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20567 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20568 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20569 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20571 zip2
->salt_len
= 16;
20574 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20575 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20576 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20577 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20579 zip2
->verify_bytes
= verify_bytes
;
20581 zip2
->compress_length
= compress_length
;
20583 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20585 for (uint i
= 0; i
< param6_len
; i
+= 2)
20587 const char p0
= data_buf
[i
+ 0];
20588 const char p1
= data_buf
[i
+ 1];
20590 *data_buf_ptr
++ = hex_convert (p1
) << 0
20591 | hex_convert (p0
) << 4;
20596 *data_buf_ptr
= 0x80;
20598 char *auth_ptr
= (char *) zip2
->auth_buf
;
20600 for (uint i
= 0; i
< param7_len
; i
+= 2)
20602 const char p0
= auth
[i
+ 0];
20603 const char p1
= auth
[i
+ 1];
20605 *auth_ptr
++ = hex_convert (p1
) << 0
20606 | hex_convert (p0
) << 4;
20615 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20616 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20617 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20618 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20619 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20620 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20621 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20622 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20624 salt
->salt_len
= 32;
20626 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20629 * digest buf (fake)
20632 digest
[0] = zip2
->auth_buf
[0];
20633 digest
[1] = zip2
->auth_buf
[1];
20634 digest
[2] = zip2
->auth_buf
[2];
20635 digest
[3] = zip2
->auth_buf
[3];
20637 return (PARSER_OK
);
20640 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20642 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20644 u32
*digest
= (u32
*) hash_buf
->digest
;
20646 salt_t
*salt
= hash_buf
->salt
;
20648 win8phone_t
*esalt
= hash_buf
->esalt
;
20650 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20651 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20652 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20653 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20654 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20655 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20656 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20657 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20659 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20661 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20663 u32
*salt_buf
= esalt
->salt_buf
;
20665 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20667 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20670 salt
->salt_buf
[0] = salt_buf
[0];
20671 salt
->salt_buf
[1] = salt_buf
[1];
20672 salt
->salt_buf
[2] = salt_buf
[2];
20673 salt
->salt_buf
[3] = salt_buf
[3];
20674 salt
->salt_buf
[4] = salt_buf
[4];
20675 salt
->salt_buf
[5] = salt_buf
[5];
20676 salt
->salt_buf
[6] = salt_buf
[6];
20677 salt
->salt_buf
[7] = salt_buf
[7];
20679 salt
->salt_len
= 64;
20681 return (PARSER_OK
);
20685 * parallel running threads
20690 BOOL WINAPI
sigHandler_default (DWORD sig
)
20694 case CTRL_CLOSE_EVENT
:
20697 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20698 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20699 * function otherwise it is too late (e.g. after returning from this function)
20704 SetConsoleCtrlHandler (NULL
, TRUE
);
20711 case CTRL_LOGOFF_EVENT
:
20712 case CTRL_SHUTDOWN_EVENT
:
20716 SetConsoleCtrlHandler (NULL
, TRUE
);
20724 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20728 case CTRL_CLOSE_EVENT
:
20732 SetConsoleCtrlHandler (NULL
, TRUE
);
20739 case CTRL_LOGOFF_EVENT
:
20740 case CTRL_SHUTDOWN_EVENT
:
20744 SetConsoleCtrlHandler (NULL
, TRUE
);
20752 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20754 if (callback
== NULL
)
20756 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20760 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20766 void sigHandler_default (int sig
)
20770 signal (sig
, NULL
);
20773 void sigHandler_benchmark (int sig
)
20777 signal (sig
, NULL
);
20780 void hc_signal (void (callback
) (int))
20782 if (callback
== NULL
) callback
= SIG_DFL
;
20784 signal (SIGINT
, callback
);
20785 signal (SIGTERM
, callback
);
20786 signal (SIGABRT
, callback
);
20791 void status_display ();
20793 void *thread_keypress (void *p
)
20795 uint quiet
= data
.quiet
;
20799 while (data
.shutdown_outer
== 0)
20801 int ch
= tty_getchar();
20803 if (ch
== -1) break;
20805 if (ch
== 0) continue;
20807 //https://github.com/hashcat/hashcat/issues/302
20812 hc_thread_mutex_lock (mux_display
);
20828 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20829 if (quiet
== 0) fflush (stdout
);
20841 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20842 if (quiet
== 0) fflush (stdout
);
20854 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20855 if (quiet
== 0) fflush (stdout
);
20867 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20868 if (quiet
== 0) fflush (stdout
);
20876 stop_at_checkpoint ();
20880 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20881 if (quiet
== 0) fflush (stdout
);
20894 //https://github.com/hashcat/hashcat/issues/302
20899 hc_thread_mutex_unlock (mux_display
);
20911 bool class_num (const u8 c
)
20913 return ((c
>= '0') && (c
<= '9'));
20916 bool class_lower (const u8 c
)
20918 return ((c
>= 'a') && (c
<= 'z'));
20921 bool class_upper (const u8 c
)
20923 return ((c
>= 'A') && (c
<= 'Z'));
20926 bool class_alpha (const u8 c
)
20928 return (class_lower (c
) || class_upper (c
));
20931 int conv_ctoi (const u8 c
)
20937 else if (class_upper (c
))
20939 return c
- 'A' + 10;
20945 int conv_itoc (const u8 c
)
20953 return c
+ 'A' - 10;
20963 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20964 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20965 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20966 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20967 #define MAX_KERNEL_RULES 255
20968 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20969 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20970 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20972 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20973 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20974 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20975 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20977 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20982 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20984 switch (rule_buf
[rule_pos
])
20990 case RULE_OP_MANGLE_NOOP
:
20991 SET_NAME (rule
, rule_buf
[rule_pos
]);
20994 case RULE_OP_MANGLE_LREST
:
20995 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 case RULE_OP_MANGLE_UREST
:
20999 SET_NAME (rule
, rule_buf
[rule_pos
]);
21002 case RULE_OP_MANGLE_LREST_UFIRST
:
21003 SET_NAME (rule
, rule_buf
[rule_pos
]);
21006 case RULE_OP_MANGLE_UREST_LFIRST
:
21007 SET_NAME (rule
, rule_buf
[rule_pos
]);
21010 case RULE_OP_MANGLE_TREST
:
21011 SET_NAME (rule
, rule_buf
[rule_pos
]);
21014 case RULE_OP_MANGLE_TOGGLE_AT
:
21015 SET_NAME (rule
, rule_buf
[rule_pos
]);
21016 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21019 case RULE_OP_MANGLE_REVERSE
:
21020 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 case RULE_OP_MANGLE_DUPEWORD
:
21024 SET_NAME (rule
, rule_buf
[rule_pos
]);
21027 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21028 SET_NAME (rule
, rule_buf
[rule_pos
]);
21029 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21032 case RULE_OP_MANGLE_REFLECT
:
21033 SET_NAME (rule
, rule_buf
[rule_pos
]);
21036 case RULE_OP_MANGLE_ROTATE_LEFT
:
21037 SET_NAME (rule
, rule_buf
[rule_pos
]);
21040 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21041 SET_NAME (rule
, rule_buf
[rule_pos
]);
21044 case RULE_OP_MANGLE_APPEND
:
21045 SET_NAME (rule
, rule_buf
[rule_pos
]);
21046 SET_P0 (rule
, rule_buf
[rule_pos
]);
21049 case RULE_OP_MANGLE_PREPEND
:
21050 SET_NAME (rule
, rule_buf
[rule_pos
]);
21051 SET_P0 (rule
, rule_buf
[rule_pos
]);
21054 case RULE_OP_MANGLE_DELETE_FIRST
:
21055 SET_NAME (rule
, rule_buf
[rule_pos
]);
21058 case RULE_OP_MANGLE_DELETE_LAST
:
21059 SET_NAME (rule
, rule_buf
[rule_pos
]);
21062 case RULE_OP_MANGLE_DELETE_AT
:
21063 SET_NAME (rule
, rule_buf
[rule_pos
]);
21064 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21067 case RULE_OP_MANGLE_EXTRACT
:
21068 SET_NAME (rule
, rule_buf
[rule_pos
]);
21069 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21070 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21073 case RULE_OP_MANGLE_OMIT
:
21074 SET_NAME (rule
, rule_buf
[rule_pos
]);
21075 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21076 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21079 case RULE_OP_MANGLE_INSERT
:
21080 SET_NAME (rule
, rule_buf
[rule_pos
]);
21081 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21082 SET_P1 (rule
, rule_buf
[rule_pos
]);
21085 case RULE_OP_MANGLE_OVERSTRIKE
:
21086 SET_NAME (rule
, rule_buf
[rule_pos
]);
21087 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21088 SET_P1 (rule
, rule_buf
[rule_pos
]);
21091 case RULE_OP_MANGLE_TRUNCATE_AT
:
21092 SET_NAME (rule
, rule_buf
[rule_pos
]);
21093 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21096 case RULE_OP_MANGLE_REPLACE
:
21097 SET_NAME (rule
, rule_buf
[rule_pos
]);
21098 SET_P0 (rule
, rule_buf
[rule_pos
]);
21099 SET_P1 (rule
, rule_buf
[rule_pos
]);
21102 case RULE_OP_MANGLE_PURGECHAR
:
21106 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21110 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21111 SET_NAME (rule
, rule_buf
[rule_pos
]);
21112 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21115 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21116 SET_NAME (rule
, rule_buf
[rule_pos
]);
21117 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21120 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21121 SET_NAME (rule
, rule_buf
[rule_pos
]);
21124 case RULE_OP_MANGLE_SWITCH_FIRST
:
21125 SET_NAME (rule
, rule_buf
[rule_pos
]);
21128 case RULE_OP_MANGLE_SWITCH_LAST
:
21129 SET_NAME (rule
, rule_buf
[rule_pos
]);
21132 case RULE_OP_MANGLE_SWITCH_AT
:
21133 SET_NAME (rule
, rule_buf
[rule_pos
]);
21134 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21135 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21138 case RULE_OP_MANGLE_CHR_SHIFTL
:
21139 SET_NAME (rule
, rule_buf
[rule_pos
]);
21140 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21143 case RULE_OP_MANGLE_CHR_SHIFTR
:
21144 SET_NAME (rule
, rule_buf
[rule_pos
]);
21145 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21148 case RULE_OP_MANGLE_CHR_INCR
:
21149 SET_NAME (rule
, rule_buf
[rule_pos
]);
21150 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21153 case RULE_OP_MANGLE_CHR_DECR
:
21154 SET_NAME (rule
, rule_buf
[rule_pos
]);
21155 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21158 case RULE_OP_MANGLE_REPLACE_NP1
:
21159 SET_NAME (rule
, rule_buf
[rule_pos
]);
21160 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21163 case RULE_OP_MANGLE_REPLACE_NM1
:
21164 SET_NAME (rule
, rule_buf
[rule_pos
]);
21165 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21168 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21169 SET_NAME (rule
, rule_buf
[rule_pos
]);
21170 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21173 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21174 SET_NAME (rule
, rule_buf
[rule_pos
]);
21175 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21178 case RULE_OP_MANGLE_TITLE
:
21179 SET_NAME (rule
, rule_buf
[rule_pos
]);
21188 if (rule_pos
< rule_len
) return (-1);
21193 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21197 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21201 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21205 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21209 case RULE_OP_MANGLE_NOOP
:
21210 rule_buf
[rule_pos
] = rule_cmd
;
21213 case RULE_OP_MANGLE_LREST
:
21214 rule_buf
[rule_pos
] = rule_cmd
;
21217 case RULE_OP_MANGLE_UREST
:
21218 rule_buf
[rule_pos
] = rule_cmd
;
21221 case RULE_OP_MANGLE_LREST_UFIRST
:
21222 rule_buf
[rule_pos
] = rule_cmd
;
21225 case RULE_OP_MANGLE_UREST_LFIRST
:
21226 rule_buf
[rule_pos
] = rule_cmd
;
21229 case RULE_OP_MANGLE_TREST
:
21230 rule_buf
[rule_pos
] = rule_cmd
;
21233 case RULE_OP_MANGLE_TOGGLE_AT
:
21234 rule_buf
[rule_pos
] = rule_cmd
;
21235 GET_P0_CONV (rule
);
21238 case RULE_OP_MANGLE_REVERSE
:
21239 rule_buf
[rule_pos
] = rule_cmd
;
21242 case RULE_OP_MANGLE_DUPEWORD
:
21243 rule_buf
[rule_pos
] = rule_cmd
;
21246 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21247 rule_buf
[rule_pos
] = rule_cmd
;
21248 GET_P0_CONV (rule
);
21251 case RULE_OP_MANGLE_REFLECT
:
21252 rule_buf
[rule_pos
] = rule_cmd
;
21255 case RULE_OP_MANGLE_ROTATE_LEFT
:
21256 rule_buf
[rule_pos
] = rule_cmd
;
21259 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21260 rule_buf
[rule_pos
] = rule_cmd
;
21263 case RULE_OP_MANGLE_APPEND
:
21264 rule_buf
[rule_pos
] = rule_cmd
;
21268 case RULE_OP_MANGLE_PREPEND
:
21269 rule_buf
[rule_pos
] = rule_cmd
;
21273 case RULE_OP_MANGLE_DELETE_FIRST
:
21274 rule_buf
[rule_pos
] = rule_cmd
;
21277 case RULE_OP_MANGLE_DELETE_LAST
:
21278 rule_buf
[rule_pos
] = rule_cmd
;
21281 case RULE_OP_MANGLE_DELETE_AT
:
21282 rule_buf
[rule_pos
] = rule_cmd
;
21283 GET_P0_CONV (rule
);
21286 case RULE_OP_MANGLE_EXTRACT
:
21287 rule_buf
[rule_pos
] = rule_cmd
;
21288 GET_P0_CONV (rule
);
21289 GET_P1_CONV (rule
);
21292 case RULE_OP_MANGLE_OMIT
:
21293 rule_buf
[rule_pos
] = rule_cmd
;
21294 GET_P0_CONV (rule
);
21295 GET_P1_CONV (rule
);
21298 case RULE_OP_MANGLE_INSERT
:
21299 rule_buf
[rule_pos
] = rule_cmd
;
21300 GET_P0_CONV (rule
);
21304 case RULE_OP_MANGLE_OVERSTRIKE
:
21305 rule_buf
[rule_pos
] = rule_cmd
;
21306 GET_P0_CONV (rule
);
21310 case RULE_OP_MANGLE_TRUNCATE_AT
:
21311 rule_buf
[rule_pos
] = rule_cmd
;
21312 GET_P0_CONV (rule
);
21315 case RULE_OP_MANGLE_REPLACE
:
21316 rule_buf
[rule_pos
] = rule_cmd
;
21321 case RULE_OP_MANGLE_PURGECHAR
:
21325 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21329 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21330 rule_buf
[rule_pos
] = rule_cmd
;
21331 GET_P0_CONV (rule
);
21334 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21335 rule_buf
[rule_pos
] = rule_cmd
;
21336 GET_P0_CONV (rule
);
21339 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21340 rule_buf
[rule_pos
] = rule_cmd
;
21343 case RULE_OP_MANGLE_SWITCH_FIRST
:
21344 rule_buf
[rule_pos
] = rule_cmd
;
21347 case RULE_OP_MANGLE_SWITCH_LAST
:
21348 rule_buf
[rule_pos
] = rule_cmd
;
21351 case RULE_OP_MANGLE_SWITCH_AT
:
21352 rule_buf
[rule_pos
] = rule_cmd
;
21353 GET_P0_CONV (rule
);
21354 GET_P1_CONV (rule
);
21357 case RULE_OP_MANGLE_CHR_SHIFTL
:
21358 rule_buf
[rule_pos
] = rule_cmd
;
21359 GET_P0_CONV (rule
);
21362 case RULE_OP_MANGLE_CHR_SHIFTR
:
21363 rule_buf
[rule_pos
] = rule_cmd
;
21364 GET_P0_CONV (rule
);
21367 case RULE_OP_MANGLE_CHR_INCR
:
21368 rule_buf
[rule_pos
] = rule_cmd
;
21369 GET_P0_CONV (rule
);
21372 case RULE_OP_MANGLE_CHR_DECR
:
21373 rule_buf
[rule_pos
] = rule_cmd
;
21374 GET_P0_CONV (rule
);
21377 case RULE_OP_MANGLE_REPLACE_NP1
:
21378 rule_buf
[rule_pos
] = rule_cmd
;
21379 GET_P0_CONV (rule
);
21382 case RULE_OP_MANGLE_REPLACE_NM1
:
21383 rule_buf
[rule_pos
] = rule_cmd
;
21384 GET_P0_CONV (rule
);
21387 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21388 rule_buf
[rule_pos
] = rule_cmd
;
21389 GET_P0_CONV (rule
);
21392 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21393 rule_buf
[rule_pos
] = rule_cmd
;
21394 GET_P0_CONV (rule
);
21397 case RULE_OP_MANGLE_TITLE
:
21398 rule_buf
[rule_pos
] = rule_cmd
;
21402 return rule_pos
- 1;
21420 * CPU rules : this is from hashcat sources, cpu based rules
21423 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21424 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21426 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21427 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21428 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21430 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21431 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21432 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21434 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21438 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21443 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21447 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21452 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21456 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21461 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21466 for (l
= 0; l
< arr_len
; l
++)
21468 r
= arr_len
- 1 - l
;
21472 MANGLE_SWITCH (arr
, l
, r
);
21478 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21480 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21482 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21484 return (arr_len
* 2);
21487 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21489 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21491 int orig_len
= arr_len
;
21495 for (i
= 0; i
< times
; i
++)
21497 memcpy (&arr
[arr_len
], arr
, orig_len
);
21499 arr_len
+= orig_len
;
21505 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21507 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21509 mangle_double (arr
, arr_len
);
21511 mangle_reverse (arr
+ arr_len
, arr_len
);
21513 return (arr_len
* 2);
21516 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21521 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21523 MANGLE_SWITCH (arr
, l
, r
);
21529 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21534 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21536 MANGLE_SWITCH (arr
, l
, r
);
21542 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21544 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21548 return (arr_len
+ 1);
21551 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21553 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21557 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21559 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21564 return (arr_len
+ 1);
21567 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21569 if (upos
>= arr_len
) return (arr_len
);
21573 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21575 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21578 return (arr_len
- 1);
21581 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21583 if (upos
>= arr_len
) return (arr_len
);
21585 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21589 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21591 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21597 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21599 if (upos
>= arr_len
) return (arr_len
);
21601 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21605 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21607 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21610 return (arr_len
- ulen
);
21613 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21615 if (upos
>= arr_len
) return (arr_len
);
21617 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21621 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21623 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21628 return (arr_len
+ 1);
21631 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
)
21633 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21635 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21637 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21639 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21641 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21643 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21645 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21647 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21649 return (arr_len
+ arr2_cpy
);
21652 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21654 if (upos
>= arr_len
) return (arr_len
);
21661 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21663 if (upos
>= arr_len
) return (arr_len
);
21665 memset (arr
+ upos
, 0, arr_len
- upos
);
21670 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21674 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21676 if (arr
[arr_pos
] != oldc
) continue;
21678 arr
[arr_pos
] = newc
;
21684 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21690 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21692 if (arr
[arr_pos
] == c
) continue;
21694 arr
[ret_len
] = arr
[arr_pos
];
21702 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21704 if (ulen
> arr_len
) return (arr_len
);
21706 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21708 char cs
[100] = { 0 };
21710 memcpy (cs
, arr
, ulen
);
21714 for (i
= 0; i
< ulen
; i
++)
21718 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21724 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21726 if (ulen
> arr_len
) return (arr_len
);
21728 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21730 int upos
= arr_len
- ulen
;
21734 for (i
= 0; i
< ulen
; i
++)
21736 char c
= arr
[upos
+ i
];
21738 arr_len
= mangle_append (arr
, arr_len
, c
);
21744 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21746 if ( arr_len
== 0) return (arr_len
);
21747 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21749 char c
= arr
[upos
];
21753 for (i
= 0; i
< ulen
; i
++)
21755 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21761 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21763 if ( arr_len
== 0) return (arr_len
);
21764 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21768 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21770 int new_pos
= arr_pos
* 2;
21772 arr
[new_pos
] = arr
[arr_pos
];
21774 arr
[new_pos
+ 1] = arr
[arr_pos
];
21777 return (arr_len
* 2);
21780 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21782 if (upos
>= arr_len
) return (arr_len
);
21783 if (upos2
>= arr_len
) return (arr_len
);
21785 MANGLE_SWITCH (arr
, upos
, upos2
);
21790 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21792 MANGLE_SWITCH (arr
, upos
, upos2
);
21797 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21799 if (upos
>= arr_len
) return (arr_len
);
21806 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21808 if (upos
>= arr_len
) return (arr_len
);
21815 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21817 if (upos
>= arr_len
) return (arr_len
);
21824 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21826 if (upos
>= arr_len
) return (arr_len
);
21833 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21835 int upper_next
= 1;
21839 for (pos
= 0; pos
< arr_len
; pos
++)
21841 if (arr
[pos
] == ' ')
21852 MANGLE_UPPER_AT (arr
, pos
);
21856 MANGLE_LOWER_AT (arr
, pos
);
21863 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21865 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21871 for (j
= 0; j
< rp_gen_num
; j
++)
21878 switch ((char) get_random_num (0, 9))
21881 r
= get_random_num (0, sizeof (grp_op_nop
));
21882 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21886 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21887 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21888 p1
= get_random_num (0, sizeof (grp_pos
));
21889 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21893 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21894 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21895 p1
= get_random_num (1, 6);
21896 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21900 r
= get_random_num (0, sizeof (grp_op_chr
));
21901 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21902 p1
= get_random_num (0x20, 0x7e);
21903 rule_buf
[rule_pos
++] = (char) p1
;
21907 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21908 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21909 p1
= get_random_num (0x20, 0x7e);
21910 rule_buf
[rule_pos
++] = (char) p1
;
21911 p2
= get_random_num (0x20, 0x7e);
21913 p2
= get_random_num (0x20, 0x7e);
21914 rule_buf
[rule_pos
++] = (char) p2
;
21918 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21919 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21920 p1
= get_random_num (0, sizeof (grp_pos
));
21921 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21922 p2
= get_random_num (0x20, 0x7e);
21923 rule_buf
[rule_pos
++] = (char) p2
;
21927 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21928 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21929 p1
= get_random_num (0, sizeof (grp_pos
));
21930 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21931 p2
= get_random_num (0, sizeof (grp_pos
));
21933 p2
= get_random_num (0, sizeof (grp_pos
));
21934 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21938 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21939 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21940 p1
= get_random_num (0, sizeof (grp_pos
));
21941 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21942 p2
= get_random_num (1, sizeof (grp_pos
));
21944 p2
= get_random_num (1, sizeof (grp_pos
));
21945 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21949 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21950 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21951 p1
= get_random_num (0, sizeof (grp_pos
));
21952 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21953 p2
= get_random_num (1, sizeof (grp_pos
));
21954 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21955 p3
= get_random_num (0, sizeof (grp_pos
));
21956 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21964 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21966 char mem
[BLOCK_SIZE
] = { 0 };
21968 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21970 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21972 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21974 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21976 int out_len
= in_len
;
21977 int mem_len
= in_len
;
21979 memcpy (out
, in
, out_len
);
21983 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21988 switch (rule
[rule_pos
])
21993 case RULE_OP_MANGLE_NOOP
:
21996 case RULE_OP_MANGLE_LREST
:
21997 out_len
= mangle_lrest (out
, out_len
);
22000 case RULE_OP_MANGLE_UREST
:
22001 out_len
= mangle_urest (out
, out_len
);
22004 case RULE_OP_MANGLE_LREST_UFIRST
:
22005 out_len
= mangle_lrest (out
, out_len
);
22006 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22009 case RULE_OP_MANGLE_UREST_LFIRST
:
22010 out_len
= mangle_urest (out
, out_len
);
22011 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22014 case RULE_OP_MANGLE_TREST
:
22015 out_len
= mangle_trest (out
, out_len
);
22018 case RULE_OP_MANGLE_TOGGLE_AT
:
22019 NEXT_RULEPOS (rule_pos
);
22020 NEXT_RPTOI (rule
, rule_pos
, upos
);
22021 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22024 case RULE_OP_MANGLE_REVERSE
:
22025 out_len
= mangle_reverse (out
, out_len
);
22028 case RULE_OP_MANGLE_DUPEWORD
:
22029 out_len
= mangle_double (out
, out_len
);
22032 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22033 NEXT_RULEPOS (rule_pos
);
22034 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22035 out_len
= mangle_double_times (out
, out_len
, ulen
);
22038 case RULE_OP_MANGLE_REFLECT
:
22039 out_len
= mangle_reflect (out
, out_len
);
22042 case RULE_OP_MANGLE_ROTATE_LEFT
:
22043 mangle_rotate_left (out
, out_len
);
22046 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22047 mangle_rotate_right (out
, out_len
);
22050 case RULE_OP_MANGLE_APPEND
:
22051 NEXT_RULEPOS (rule_pos
);
22052 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22055 case RULE_OP_MANGLE_PREPEND
:
22056 NEXT_RULEPOS (rule_pos
);
22057 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22060 case RULE_OP_MANGLE_DELETE_FIRST
:
22061 out_len
= mangle_delete_at (out
, out_len
, 0);
22064 case RULE_OP_MANGLE_DELETE_LAST
:
22065 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22068 case RULE_OP_MANGLE_DELETE_AT
:
22069 NEXT_RULEPOS (rule_pos
);
22070 NEXT_RPTOI (rule
, rule_pos
, upos
);
22071 out_len
= mangle_delete_at (out
, out_len
, upos
);
22074 case RULE_OP_MANGLE_EXTRACT
:
22075 NEXT_RULEPOS (rule_pos
);
22076 NEXT_RPTOI (rule
, rule_pos
, upos
);
22077 NEXT_RULEPOS (rule_pos
);
22078 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22079 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22082 case RULE_OP_MANGLE_OMIT
:
22083 NEXT_RULEPOS (rule_pos
);
22084 NEXT_RPTOI (rule
, rule_pos
, upos
);
22085 NEXT_RULEPOS (rule_pos
);
22086 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22087 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22090 case RULE_OP_MANGLE_INSERT
:
22091 NEXT_RULEPOS (rule_pos
);
22092 NEXT_RPTOI (rule
, rule_pos
, upos
);
22093 NEXT_RULEPOS (rule_pos
);
22094 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22097 case RULE_OP_MANGLE_OVERSTRIKE
:
22098 NEXT_RULEPOS (rule_pos
);
22099 NEXT_RPTOI (rule
, rule_pos
, upos
);
22100 NEXT_RULEPOS (rule_pos
);
22101 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22104 case RULE_OP_MANGLE_TRUNCATE_AT
:
22105 NEXT_RULEPOS (rule_pos
);
22106 NEXT_RPTOI (rule
, rule_pos
, upos
);
22107 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22110 case RULE_OP_MANGLE_REPLACE
:
22111 NEXT_RULEPOS (rule_pos
);
22112 NEXT_RULEPOS (rule_pos
);
22113 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22116 case RULE_OP_MANGLE_PURGECHAR
:
22117 NEXT_RULEPOS (rule_pos
);
22118 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22121 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22125 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22126 NEXT_RULEPOS (rule_pos
);
22127 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22128 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22131 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22132 NEXT_RULEPOS (rule_pos
);
22133 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22134 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22137 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22138 out_len
= mangle_dupechar (out
, out_len
);
22141 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22142 NEXT_RULEPOS (rule_pos
);
22143 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22144 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22147 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22148 NEXT_RULEPOS (rule_pos
);
22149 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22150 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22153 case RULE_OP_MANGLE_SWITCH_FIRST
:
22154 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22157 case RULE_OP_MANGLE_SWITCH_LAST
:
22158 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22161 case RULE_OP_MANGLE_SWITCH_AT
:
22162 NEXT_RULEPOS (rule_pos
);
22163 NEXT_RPTOI (rule
, rule_pos
, upos
);
22164 NEXT_RULEPOS (rule_pos
);
22165 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22166 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22169 case RULE_OP_MANGLE_CHR_SHIFTL
:
22170 NEXT_RULEPOS (rule_pos
);
22171 NEXT_RPTOI (rule
, rule_pos
, upos
);
22172 mangle_chr_shiftl (out
, out_len
, upos
);
22175 case RULE_OP_MANGLE_CHR_SHIFTR
:
22176 NEXT_RULEPOS (rule_pos
);
22177 NEXT_RPTOI (rule
, rule_pos
, upos
);
22178 mangle_chr_shiftr (out
, out_len
, upos
);
22181 case RULE_OP_MANGLE_CHR_INCR
:
22182 NEXT_RULEPOS (rule_pos
);
22183 NEXT_RPTOI (rule
, rule_pos
, upos
);
22184 mangle_chr_incr (out
, out_len
, upos
);
22187 case RULE_OP_MANGLE_CHR_DECR
:
22188 NEXT_RULEPOS (rule_pos
);
22189 NEXT_RPTOI (rule
, rule_pos
, upos
);
22190 mangle_chr_decr (out
, out_len
, upos
);
22193 case RULE_OP_MANGLE_REPLACE_NP1
:
22194 NEXT_RULEPOS (rule_pos
);
22195 NEXT_RPTOI (rule
, rule_pos
, upos
);
22196 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22199 case RULE_OP_MANGLE_REPLACE_NM1
:
22200 NEXT_RULEPOS (rule_pos
);
22201 NEXT_RPTOI (rule
, rule_pos
, upos
);
22202 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22205 case RULE_OP_MANGLE_TITLE
:
22206 out_len
= mangle_title (out
, out_len
);
22209 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22210 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22211 NEXT_RULEPOS (rule_pos
);
22212 NEXT_RPTOI (rule
, rule_pos
, upos
);
22213 NEXT_RULEPOS (rule_pos
);
22214 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22215 NEXT_RULEPOS (rule_pos
);
22216 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22217 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22220 case RULE_OP_MANGLE_APPEND_MEMORY
:
22221 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22222 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22223 memcpy (out
+ out_len
, mem
, mem_len
);
22224 out_len
+= mem_len
;
22227 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22228 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22229 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22230 memcpy (mem
+ mem_len
, out
, out_len
);
22231 out_len
+= mem_len
;
22232 memcpy (out
, mem
, out_len
);
22235 case RULE_OP_MEMORIZE_WORD
:
22236 memcpy (mem
, out
, out_len
);
22240 case RULE_OP_REJECT_LESS
:
22241 NEXT_RULEPOS (rule_pos
);
22242 NEXT_RPTOI (rule
, rule_pos
, upos
);
22243 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22246 case RULE_OP_REJECT_GREATER
:
22247 NEXT_RULEPOS (rule_pos
);
22248 NEXT_RPTOI (rule
, rule_pos
, upos
);
22249 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22252 case RULE_OP_REJECT_CONTAIN
:
22253 NEXT_RULEPOS (rule_pos
);
22254 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22257 case RULE_OP_REJECT_NOT_CONTAIN
:
22258 NEXT_RULEPOS (rule_pos
);
22259 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22262 case RULE_OP_REJECT_EQUAL_FIRST
:
22263 NEXT_RULEPOS (rule_pos
);
22264 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22267 case RULE_OP_REJECT_EQUAL_LAST
:
22268 NEXT_RULEPOS (rule_pos
);
22269 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22272 case RULE_OP_REJECT_EQUAL_AT
:
22273 NEXT_RULEPOS (rule_pos
);
22274 NEXT_RPTOI (rule
, rule_pos
, upos
);
22275 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22276 NEXT_RULEPOS (rule_pos
);
22277 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22280 case RULE_OP_REJECT_CONTAINS
:
22281 NEXT_RULEPOS (rule_pos
);
22282 NEXT_RPTOI (rule
, rule_pos
, upos
);
22283 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22284 NEXT_RULEPOS (rule_pos
);
22285 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22286 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22289 case RULE_OP_REJECT_MEMORY
:
22290 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22294 return (RULE_RC_SYNTAX_ERROR
);
22299 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);