2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
78 #include "cpu-sha256.c"
86 int log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
117 int log_out_nn (FILE *fp
, const char *fmt
, ...)
119 if (SUPPRESS_OUTPUT
) return 0;
125 const int len
= log_final (fp
, fmt
, ap
);
132 int log_info_nn (const char *fmt
, ...)
134 if (SUPPRESS_OUTPUT
) return 0;
140 const int len
= log_final (stdout
, fmt
, ap
);
147 int log_error_nn (const char *fmt
, ...)
149 if (SUPPRESS_OUTPUT
) return 0;
155 const int len
= log_final (stderr
, fmt
, ap
);
162 int log_out (FILE *fp
, const char *fmt
, ...)
164 if (SUPPRESS_OUTPUT
) return 0;
170 const int len
= log_final (fp
, fmt
, ap
);
181 int log_info (const char *fmt
, ...)
183 if (SUPPRESS_OUTPUT
) return 0;
189 const int len
= log_final (stdout
, fmt
, ap
);
193 fputc ('\n', stdout
);
200 int log_error (const char *fmt
, ...)
202 if (SUPPRESS_OUTPUT
) return 0;
204 fputc ('\n', stderr
);
205 fputc ('\n', stderr
);
211 const int len
= log_final (stderr
, fmt
, ap
);
215 fputc ('\n', stderr
);
216 fputc ('\n', stderr
);
227 u8
int_to_base32 (const u8 c
)
229 static const u8 tbl
[0x20] =
231 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
232 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
238 u8
base32_to_int (const u8 c
)
240 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
241 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
246 u8
int_to_itoa32 (const u8 c
)
248 static const u8 tbl
[0x20] =
250 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
251 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
257 u8
itoa32_to_int (const u8 c
)
259 if ((c
>= '0') && (c
<= '9')) return c
- '0';
260 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
265 u8
int_to_itoa64 (const u8 c
)
267 static const u8 tbl
[0x40] =
269 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
270 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
271 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
272 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
278 u8
itoa64_to_int (const u8 c
)
280 static const u8 tbl
[0x100] =
282 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
283 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
284 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
285 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
286 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
287 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
288 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
289 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
290 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
291 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
292 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
293 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
294 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
295 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
296 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
297 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
303 u8
int_to_base64 (const u8 c
)
305 static const u8 tbl
[0x40] =
307 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
308 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
309 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
310 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
316 u8
base64_to_int (const u8 c
)
318 static const u8 tbl
[0x100] =
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
323 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
327 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
333 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
334 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 u8
int_to_bf64 (const u8 c
)
343 static const u8 tbl
[0x40] =
345 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
346 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
347 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
348 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
354 u8
bf64_to_int (const u8 c
)
356 static const u8 tbl
[0x100] =
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
361 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
362 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
363 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
364 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
365 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
373 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
379 u8
int_to_lotus64 (const u8 c
)
381 if (c
< 10) return '0' + c
;
382 else if (c
< 36) return 'A' + c
- 10;
383 else if (c
< 62) return 'a' + c
- 36;
384 else if (c
== 62) return '+';
385 else if (c
== 63) return '/';
390 u8
lotus64_to_int (const u8 c
)
392 if ((c
>= '0') && (c
<= '9')) return c
- '0';
393 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
394 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
395 else if (c
== '+') return 62;
396 else if (c
== '/') return 63;
402 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
404 const u8
*in_ptr
= in_buf
;
406 u8
*out_ptr
= out_buf
;
408 for (int i
= 0; i
< in_len
; i
+= 8)
410 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
411 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
412 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
413 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
414 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
415 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
416 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
417 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
419 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
420 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
421 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
422 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
423 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
429 for (int i
= 0; i
< in_len
; i
++)
431 if (in_buf
[i
] != '=') continue;
436 int out_len
= (in_len
* 5) / 8;
441 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
443 const u8
*in_ptr
= in_buf
;
445 u8
*out_ptr
= out_buf
;
447 for (int i
= 0; i
< in_len
; i
+= 5)
449 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
450 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
451 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
452 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
453 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
454 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
455 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
456 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
458 out_ptr
[0] = out_val0
& 0x7f;
459 out_ptr
[1] = out_val1
& 0x7f;
460 out_ptr
[2] = out_val2
& 0x7f;
461 out_ptr
[3] = out_val3
& 0x7f;
462 out_ptr
[4] = out_val4
& 0x7f;
463 out_ptr
[5] = out_val5
& 0x7f;
464 out_ptr
[6] = out_val6
& 0x7f;
465 out_ptr
[7] = out_val7
& 0x7f;
471 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
475 out_buf
[out_len
] = '=';
483 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
485 const u8
*in_ptr
= in_buf
;
487 u8
*out_ptr
= out_buf
;
489 for (int i
= 0; i
< in_len
; i
+= 4)
491 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
492 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
493 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
494 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
496 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
497 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
498 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
504 for (int i
= 0; i
< in_len
; i
++)
506 if (in_buf
[i
] != '=') continue;
511 int out_len
= (in_len
* 6) / 8;
516 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
518 const u8
*in_ptr
= in_buf
;
520 u8
*out_ptr
= out_buf
;
522 for (int i
= 0; i
< in_len
; i
+= 3)
524 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
525 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
526 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
527 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
529 out_ptr
[0] = out_val0
& 0x7f;
530 out_ptr
[1] = out_val1
& 0x7f;
531 out_ptr
[2] = out_val2
& 0x7f;
532 out_ptr
[3] = out_val3
& 0x7f;
538 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
542 out_buf
[out_len
] = '=';
550 int is_valid_hex_char (const u8 c
)
552 if ((c
>= '0') && (c
<= '9')) return 1;
553 if ((c
>= 'A') && (c
<= 'F')) return 1;
554 if ((c
>= 'a') && (c
<= 'f')) return 1;
559 u8
hex_convert (const u8 c
)
561 return (c
& 15) + (c
>> 6) * 9;
564 u8
hex_to_u8 (const u8 hex
[2])
568 v
|= (hex_convert (hex
[1]) << 0);
569 v
|= (hex_convert (hex
[0]) << 4);
574 u32
hex_to_u32 (const u8 hex
[8])
578 v
|= ((u32
) hex_convert (hex
[7])) << 0;
579 v
|= ((u32
) hex_convert (hex
[6])) << 4;
580 v
|= ((u32
) hex_convert (hex
[5])) << 8;
581 v
|= ((u32
) hex_convert (hex
[4])) << 12;
582 v
|= ((u32
) hex_convert (hex
[3])) << 16;
583 v
|= ((u32
) hex_convert (hex
[2])) << 20;
584 v
|= ((u32
) hex_convert (hex
[1])) << 24;
585 v
|= ((u32
) hex_convert (hex
[0])) << 28;
590 u64
hex_to_u64 (const u8 hex
[16])
594 v
|= ((u64
) hex_convert (hex
[15]) << 0);
595 v
|= ((u64
) hex_convert (hex
[14]) << 4);
596 v
|= ((u64
) hex_convert (hex
[13]) << 8);
597 v
|= ((u64
) hex_convert (hex
[12]) << 12);
598 v
|= ((u64
) hex_convert (hex
[11]) << 16);
599 v
|= ((u64
) hex_convert (hex
[10]) << 20);
600 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
601 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
602 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
603 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
604 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
605 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
606 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
607 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
608 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
609 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
614 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
616 hex
[0] = v
>> 28 & 15;
617 hex
[1] = v
>> 24 & 15;
618 hex
[2] = v
>> 20 & 15;
619 hex
[3] = v
>> 16 & 15;
620 hex
[4] = v
>> 12 & 15;
621 hex
[5] = v
>> 8 & 15;
622 hex
[6] = v
>> 4 & 15;
623 hex
[7] = v
>> 0 & 15;
627 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
628 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
629 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
630 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
631 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
632 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
633 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
634 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
641 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
645 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
654 for (int i
= 0; i
< 16; i
+= 4)
664 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
671 out
[i
+ 0] = _out
[0];
672 out
[i
+ 1] = _out
[1];
673 out
[i
+ 2] = _out
[2];
674 out
[i
+ 3] = _out
[3];
683 static void juniper_decrypt_hash (char *in
, char *out
)
687 u8 base64_buf
[100] = { 0 };
689 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
693 u32 juniper_iv
[4] = { 0 };
695 memcpy (juniper_iv
, base64_buf
, 12);
697 memcpy (out
, juniper_iv
, 12);
701 u32 juniper_key
[4] = { 0 };
703 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
704 juniper_key
[1] = byte_swap_32 (0x8df91059);
705 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
706 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
710 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
711 u32
*out_ptr
= (u32
*) (out
+ 12);
713 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
716 void phpass_decode (u8 digest
[16], u8 buf
[22])
720 l
= itoa64_to_int (buf
[ 0]) << 0;
721 l
|= itoa64_to_int (buf
[ 1]) << 6;
722 l
|= itoa64_to_int (buf
[ 2]) << 12;
723 l
|= itoa64_to_int (buf
[ 3]) << 18;
725 digest
[ 0] = (l
>> 0) & 0xff;
726 digest
[ 1] = (l
>> 8) & 0xff;
727 digest
[ 2] = (l
>> 16) & 0xff;
729 l
= itoa64_to_int (buf
[ 4]) << 0;
730 l
|= itoa64_to_int (buf
[ 5]) << 6;
731 l
|= itoa64_to_int (buf
[ 6]) << 12;
732 l
|= itoa64_to_int (buf
[ 7]) << 18;
734 digest
[ 3] = (l
>> 0) & 0xff;
735 digest
[ 4] = (l
>> 8) & 0xff;
736 digest
[ 5] = (l
>> 16) & 0xff;
738 l
= itoa64_to_int (buf
[ 8]) << 0;
739 l
|= itoa64_to_int (buf
[ 9]) << 6;
740 l
|= itoa64_to_int (buf
[10]) << 12;
741 l
|= itoa64_to_int (buf
[11]) << 18;
743 digest
[ 6] = (l
>> 0) & 0xff;
744 digest
[ 7] = (l
>> 8) & 0xff;
745 digest
[ 8] = (l
>> 16) & 0xff;
747 l
= itoa64_to_int (buf
[12]) << 0;
748 l
|= itoa64_to_int (buf
[13]) << 6;
749 l
|= itoa64_to_int (buf
[14]) << 12;
750 l
|= itoa64_to_int (buf
[15]) << 18;
752 digest
[ 9] = (l
>> 0) & 0xff;
753 digest
[10] = (l
>> 8) & 0xff;
754 digest
[11] = (l
>> 16) & 0xff;
756 l
= itoa64_to_int (buf
[16]) << 0;
757 l
|= itoa64_to_int (buf
[17]) << 6;
758 l
|= itoa64_to_int (buf
[18]) << 12;
759 l
|= itoa64_to_int (buf
[19]) << 18;
761 digest
[12] = (l
>> 0) & 0xff;
762 digest
[13] = (l
>> 8) & 0xff;
763 digest
[14] = (l
>> 16) & 0xff;
765 l
= itoa64_to_int (buf
[20]) << 0;
766 l
|= itoa64_to_int (buf
[21]) << 6;
768 digest
[15] = (l
>> 0) & 0xff;
771 void phpass_encode (u8 digest
[16], u8 buf
[22])
775 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
777 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
784 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
791 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[11] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
798 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
800 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
801 buf
[15] = int_to_itoa64 (l
& 0x3f);
803 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
805 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
806 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
807 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
808 buf
[19] = int_to_itoa64 (l
& 0x3f);
810 l
= (digest
[15] << 0);
812 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
813 buf
[21] = int_to_itoa64 (l
& 0x3f);
816 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
820 l
= itoa64_to_int (buf
[ 0]) << 0;
821 l
|= itoa64_to_int (buf
[ 1]) << 6;
822 l
|= itoa64_to_int (buf
[ 2]) << 12;
823 l
|= itoa64_to_int (buf
[ 3]) << 18;
825 digest
[ 0] = (l
>> 16) & 0xff;
826 digest
[ 6] = (l
>> 8) & 0xff;
827 digest
[12] = (l
>> 0) & 0xff;
829 l
= itoa64_to_int (buf
[ 4]) << 0;
830 l
|= itoa64_to_int (buf
[ 5]) << 6;
831 l
|= itoa64_to_int (buf
[ 6]) << 12;
832 l
|= itoa64_to_int (buf
[ 7]) << 18;
834 digest
[ 1] = (l
>> 16) & 0xff;
835 digest
[ 7] = (l
>> 8) & 0xff;
836 digest
[13] = (l
>> 0) & 0xff;
838 l
= itoa64_to_int (buf
[ 8]) << 0;
839 l
|= itoa64_to_int (buf
[ 9]) << 6;
840 l
|= itoa64_to_int (buf
[10]) << 12;
841 l
|= itoa64_to_int (buf
[11]) << 18;
843 digest
[ 2] = (l
>> 16) & 0xff;
844 digest
[ 8] = (l
>> 8) & 0xff;
845 digest
[14] = (l
>> 0) & 0xff;
847 l
= itoa64_to_int (buf
[12]) << 0;
848 l
|= itoa64_to_int (buf
[13]) << 6;
849 l
|= itoa64_to_int (buf
[14]) << 12;
850 l
|= itoa64_to_int (buf
[15]) << 18;
852 digest
[ 3] = (l
>> 16) & 0xff;
853 digest
[ 9] = (l
>> 8) & 0xff;
854 digest
[15] = (l
>> 0) & 0xff;
856 l
= itoa64_to_int (buf
[16]) << 0;
857 l
|= itoa64_to_int (buf
[17]) << 6;
858 l
|= itoa64_to_int (buf
[18]) << 12;
859 l
|= itoa64_to_int (buf
[19]) << 18;
861 digest
[ 4] = (l
>> 16) & 0xff;
862 digest
[10] = (l
>> 8) & 0xff;
863 digest
[ 5] = (l
>> 0) & 0xff;
865 l
= itoa64_to_int (buf
[20]) << 0;
866 l
|= itoa64_to_int (buf
[21]) << 6;
868 digest
[11] = (l
>> 0) & 0xff;
871 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
875 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
877 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
884 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
891 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
898 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
900 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
903 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
905 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
906 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
907 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
908 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
910 l
= (digest
[11] << 0);
912 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
913 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
916 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
920 l
= itoa64_to_int (buf
[ 0]) << 0;
921 l
|= itoa64_to_int (buf
[ 1]) << 6;
922 l
|= itoa64_to_int (buf
[ 2]) << 12;
923 l
|= itoa64_to_int (buf
[ 3]) << 18;
925 digest
[ 0] = (l
>> 16) & 0xff;
926 digest
[21] = (l
>> 8) & 0xff;
927 digest
[42] = (l
>> 0) & 0xff;
929 l
= itoa64_to_int (buf
[ 4]) << 0;
930 l
|= itoa64_to_int (buf
[ 5]) << 6;
931 l
|= itoa64_to_int (buf
[ 6]) << 12;
932 l
|= itoa64_to_int (buf
[ 7]) << 18;
934 digest
[22] = (l
>> 16) & 0xff;
935 digest
[43] = (l
>> 8) & 0xff;
936 digest
[ 1] = (l
>> 0) & 0xff;
938 l
= itoa64_to_int (buf
[ 8]) << 0;
939 l
|= itoa64_to_int (buf
[ 9]) << 6;
940 l
|= itoa64_to_int (buf
[10]) << 12;
941 l
|= itoa64_to_int (buf
[11]) << 18;
943 digest
[44] = (l
>> 16) & 0xff;
944 digest
[ 2] = (l
>> 8) & 0xff;
945 digest
[23] = (l
>> 0) & 0xff;
947 l
= itoa64_to_int (buf
[12]) << 0;
948 l
|= itoa64_to_int (buf
[13]) << 6;
949 l
|= itoa64_to_int (buf
[14]) << 12;
950 l
|= itoa64_to_int (buf
[15]) << 18;
952 digest
[ 3] = (l
>> 16) & 0xff;
953 digest
[24] = (l
>> 8) & 0xff;
954 digest
[45] = (l
>> 0) & 0xff;
956 l
= itoa64_to_int (buf
[16]) << 0;
957 l
|= itoa64_to_int (buf
[17]) << 6;
958 l
|= itoa64_to_int (buf
[18]) << 12;
959 l
|= itoa64_to_int (buf
[19]) << 18;
961 digest
[25] = (l
>> 16) & 0xff;
962 digest
[46] = (l
>> 8) & 0xff;
963 digest
[ 4] = (l
>> 0) & 0xff;
965 l
= itoa64_to_int (buf
[20]) << 0;
966 l
|= itoa64_to_int (buf
[21]) << 6;
967 l
|= itoa64_to_int (buf
[22]) << 12;
968 l
|= itoa64_to_int (buf
[23]) << 18;
970 digest
[47] = (l
>> 16) & 0xff;
971 digest
[ 5] = (l
>> 8) & 0xff;
972 digest
[26] = (l
>> 0) & 0xff;
974 l
= itoa64_to_int (buf
[24]) << 0;
975 l
|= itoa64_to_int (buf
[25]) << 6;
976 l
|= itoa64_to_int (buf
[26]) << 12;
977 l
|= itoa64_to_int (buf
[27]) << 18;
979 digest
[ 6] = (l
>> 16) & 0xff;
980 digest
[27] = (l
>> 8) & 0xff;
981 digest
[48] = (l
>> 0) & 0xff;
983 l
= itoa64_to_int (buf
[28]) << 0;
984 l
|= itoa64_to_int (buf
[29]) << 6;
985 l
|= itoa64_to_int (buf
[30]) << 12;
986 l
|= itoa64_to_int (buf
[31]) << 18;
988 digest
[28] = (l
>> 16) & 0xff;
989 digest
[49] = (l
>> 8) & 0xff;
990 digest
[ 7] = (l
>> 0) & 0xff;
992 l
= itoa64_to_int (buf
[32]) << 0;
993 l
|= itoa64_to_int (buf
[33]) << 6;
994 l
|= itoa64_to_int (buf
[34]) << 12;
995 l
|= itoa64_to_int (buf
[35]) << 18;
997 digest
[50] = (l
>> 16) & 0xff;
998 digest
[ 8] = (l
>> 8) & 0xff;
999 digest
[29] = (l
>> 0) & 0xff;
1001 l
= itoa64_to_int (buf
[36]) << 0;
1002 l
|= itoa64_to_int (buf
[37]) << 6;
1003 l
|= itoa64_to_int (buf
[38]) << 12;
1004 l
|= itoa64_to_int (buf
[39]) << 18;
1006 digest
[ 9] = (l
>> 16) & 0xff;
1007 digest
[30] = (l
>> 8) & 0xff;
1008 digest
[51] = (l
>> 0) & 0xff;
1010 l
= itoa64_to_int (buf
[40]) << 0;
1011 l
|= itoa64_to_int (buf
[41]) << 6;
1012 l
|= itoa64_to_int (buf
[42]) << 12;
1013 l
|= itoa64_to_int (buf
[43]) << 18;
1015 digest
[31] = (l
>> 16) & 0xff;
1016 digest
[52] = (l
>> 8) & 0xff;
1017 digest
[10] = (l
>> 0) & 0xff;
1019 l
= itoa64_to_int (buf
[44]) << 0;
1020 l
|= itoa64_to_int (buf
[45]) << 6;
1021 l
|= itoa64_to_int (buf
[46]) << 12;
1022 l
|= itoa64_to_int (buf
[47]) << 18;
1024 digest
[53] = (l
>> 16) & 0xff;
1025 digest
[11] = (l
>> 8) & 0xff;
1026 digest
[32] = (l
>> 0) & 0xff;
1028 l
= itoa64_to_int (buf
[48]) << 0;
1029 l
|= itoa64_to_int (buf
[49]) << 6;
1030 l
|= itoa64_to_int (buf
[50]) << 12;
1031 l
|= itoa64_to_int (buf
[51]) << 18;
1033 digest
[12] = (l
>> 16) & 0xff;
1034 digest
[33] = (l
>> 8) & 0xff;
1035 digest
[54] = (l
>> 0) & 0xff;
1037 l
= itoa64_to_int (buf
[52]) << 0;
1038 l
|= itoa64_to_int (buf
[53]) << 6;
1039 l
|= itoa64_to_int (buf
[54]) << 12;
1040 l
|= itoa64_to_int (buf
[55]) << 18;
1042 digest
[34] = (l
>> 16) & 0xff;
1043 digest
[55] = (l
>> 8) & 0xff;
1044 digest
[13] = (l
>> 0) & 0xff;
1046 l
= itoa64_to_int (buf
[56]) << 0;
1047 l
|= itoa64_to_int (buf
[57]) << 6;
1048 l
|= itoa64_to_int (buf
[58]) << 12;
1049 l
|= itoa64_to_int (buf
[59]) << 18;
1051 digest
[56] = (l
>> 16) & 0xff;
1052 digest
[14] = (l
>> 8) & 0xff;
1053 digest
[35] = (l
>> 0) & 0xff;
1055 l
= itoa64_to_int (buf
[60]) << 0;
1056 l
|= itoa64_to_int (buf
[61]) << 6;
1057 l
|= itoa64_to_int (buf
[62]) << 12;
1058 l
|= itoa64_to_int (buf
[63]) << 18;
1060 digest
[15] = (l
>> 16) & 0xff;
1061 digest
[36] = (l
>> 8) & 0xff;
1062 digest
[57] = (l
>> 0) & 0xff;
1064 l
= itoa64_to_int (buf
[64]) << 0;
1065 l
|= itoa64_to_int (buf
[65]) << 6;
1066 l
|= itoa64_to_int (buf
[66]) << 12;
1067 l
|= itoa64_to_int (buf
[67]) << 18;
1069 digest
[37] = (l
>> 16) & 0xff;
1070 digest
[58] = (l
>> 8) & 0xff;
1071 digest
[16] = (l
>> 0) & 0xff;
1073 l
= itoa64_to_int (buf
[68]) << 0;
1074 l
|= itoa64_to_int (buf
[69]) << 6;
1075 l
|= itoa64_to_int (buf
[70]) << 12;
1076 l
|= itoa64_to_int (buf
[71]) << 18;
1078 digest
[59] = (l
>> 16) & 0xff;
1079 digest
[17] = (l
>> 8) & 0xff;
1080 digest
[38] = (l
>> 0) & 0xff;
1082 l
= itoa64_to_int (buf
[72]) << 0;
1083 l
|= itoa64_to_int (buf
[73]) << 6;
1084 l
|= itoa64_to_int (buf
[74]) << 12;
1085 l
|= itoa64_to_int (buf
[75]) << 18;
1087 digest
[18] = (l
>> 16) & 0xff;
1088 digest
[39] = (l
>> 8) & 0xff;
1089 digest
[60] = (l
>> 0) & 0xff;
1091 l
= itoa64_to_int (buf
[76]) << 0;
1092 l
|= itoa64_to_int (buf
[77]) << 6;
1093 l
|= itoa64_to_int (buf
[78]) << 12;
1094 l
|= itoa64_to_int (buf
[79]) << 18;
1096 digest
[40] = (l
>> 16) & 0xff;
1097 digest
[61] = (l
>> 8) & 0xff;
1098 digest
[19] = (l
>> 0) & 0xff;
1100 l
= itoa64_to_int (buf
[80]) << 0;
1101 l
|= itoa64_to_int (buf
[81]) << 6;
1102 l
|= itoa64_to_int (buf
[82]) << 12;
1103 l
|= itoa64_to_int (buf
[83]) << 18;
1105 digest
[62] = (l
>> 16) & 0xff;
1106 digest
[20] = (l
>> 8) & 0xff;
1107 digest
[41] = (l
>> 0) & 0xff;
1109 l
= itoa64_to_int (buf
[84]) << 0;
1110 l
|= itoa64_to_int (buf
[85]) << 6;
1112 digest
[63] = (l
>> 0) & 0xff;
1115 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1119 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1121 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1128 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1135 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1142 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1149 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1156 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1163 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1170 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1177 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1184 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1191 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1198 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1205 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1212 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1219 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1226 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1233 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1240 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1247 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1254 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1256 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1259 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1261 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1262 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1263 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1264 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1266 l
= 0 | 0 | (digest
[63] << 0);
1268 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1269 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1272 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1276 l
= itoa64_to_int (buf
[ 0]) << 0;
1277 l
|= itoa64_to_int (buf
[ 1]) << 6;
1278 l
|= itoa64_to_int (buf
[ 2]) << 12;
1279 l
|= itoa64_to_int (buf
[ 3]) << 18;
1281 digest
[ 2] = (l
>> 0) & 0xff;
1282 digest
[ 1] = (l
>> 8) & 0xff;
1283 digest
[ 0] = (l
>> 16) & 0xff;
1285 l
= itoa64_to_int (buf
[ 4]) << 0;
1286 l
|= itoa64_to_int (buf
[ 5]) << 6;
1287 l
|= itoa64_to_int (buf
[ 6]) << 12;
1288 l
|= itoa64_to_int (buf
[ 7]) << 18;
1290 digest
[ 5] = (l
>> 0) & 0xff;
1291 digest
[ 4] = (l
>> 8) & 0xff;
1292 digest
[ 3] = (l
>> 16) & 0xff;
1294 l
= itoa64_to_int (buf
[ 8]) << 0;
1295 l
|= itoa64_to_int (buf
[ 9]) << 6;
1296 l
|= itoa64_to_int (buf
[10]) << 12;
1297 l
|= itoa64_to_int (buf
[11]) << 18;
1299 digest
[ 8] = (l
>> 0) & 0xff;
1300 digest
[ 7] = (l
>> 8) & 0xff;
1301 digest
[ 6] = (l
>> 16) & 0xff;
1303 l
= itoa64_to_int (buf
[12]) << 0;
1304 l
|= itoa64_to_int (buf
[13]) << 6;
1305 l
|= itoa64_to_int (buf
[14]) << 12;
1306 l
|= itoa64_to_int (buf
[15]) << 18;
1308 digest
[11] = (l
>> 0) & 0xff;
1309 digest
[10] = (l
>> 8) & 0xff;
1310 digest
[ 9] = (l
>> 16) & 0xff;
1312 l
= itoa64_to_int (buf
[16]) << 0;
1313 l
|= itoa64_to_int (buf
[17]) << 6;
1314 l
|= itoa64_to_int (buf
[18]) << 12;
1315 l
|= itoa64_to_int (buf
[19]) << 18;
1317 digest
[14] = (l
>> 0) & 0xff;
1318 digest
[13] = (l
>> 8) & 0xff;
1319 digest
[12] = (l
>> 16) & 0xff;
1321 l
= itoa64_to_int (buf
[20]) << 0;
1322 l
|= itoa64_to_int (buf
[21]) << 6;
1323 l
|= itoa64_to_int (buf
[22]) << 12;
1324 l
|= itoa64_to_int (buf
[23]) << 18;
1326 digest
[17] = (l
>> 0) & 0xff;
1327 digest
[16] = (l
>> 8) & 0xff;
1328 digest
[15] = (l
>> 16) & 0xff;
1330 l
= itoa64_to_int (buf
[24]) << 0;
1331 l
|= itoa64_to_int (buf
[25]) << 6;
1332 l
|= itoa64_to_int (buf
[26]) << 12;
1334 digest
[19] = (l
>> 8) & 0xff;
1335 digest
[18] = (l
>> 16) & 0xff;
1338 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1342 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1344 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1351 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1358 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[11] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1365 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[15] = int_to_itoa64 (l
& 0x3f);
1370 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1372 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1375 buf
[19] = int_to_itoa64 (l
& 0x3f);
1377 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1379 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1380 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1381 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1382 buf
[23] = int_to_itoa64 (l
& 0x3f);
1384 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1386 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1387 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1388 buf
[26] = int_to_itoa64 (l
& 0x3f);
1391 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1395 l
= itoa64_to_int (buf
[ 0]) << 0;
1396 l
|= itoa64_to_int (buf
[ 1]) << 6;
1397 l
|= itoa64_to_int (buf
[ 2]) << 12;
1398 l
|= itoa64_to_int (buf
[ 3]) << 18;
1400 digest
[ 2] = (l
>> 0) & 0xff;
1401 digest
[ 1] = (l
>> 8) & 0xff;
1402 digest
[ 0] = (l
>> 16) & 0xff;
1404 l
= itoa64_to_int (buf
[ 4]) << 0;
1405 l
|= itoa64_to_int (buf
[ 5]) << 6;
1406 l
|= itoa64_to_int (buf
[ 6]) << 12;
1407 l
|= itoa64_to_int (buf
[ 7]) << 18;
1409 digest
[ 5] = (l
>> 0) & 0xff;
1410 digest
[ 4] = (l
>> 8) & 0xff;
1411 digest
[ 3] = (l
>> 16) & 0xff;
1413 l
= itoa64_to_int (buf
[ 8]) << 0;
1414 l
|= itoa64_to_int (buf
[ 9]) << 6;
1415 l
|= itoa64_to_int (buf
[10]) << 12;
1416 l
|= itoa64_to_int (buf
[11]) << 18;
1418 digest
[ 8] = (l
>> 0) & 0xff;
1419 digest
[ 7] = (l
>> 8) & 0xff;
1420 digest
[ 6] = (l
>> 16) & 0xff;
1422 l
= itoa64_to_int (buf
[12]) << 0;
1423 l
|= itoa64_to_int (buf
[13]) << 6;
1424 l
|= itoa64_to_int (buf
[14]) << 12;
1425 l
|= itoa64_to_int (buf
[15]) << 18;
1427 digest
[11] = (l
>> 0) & 0xff;
1428 digest
[10] = (l
>> 8) & 0xff;
1429 digest
[ 9] = (l
>> 16) & 0xff;
1431 l
= itoa64_to_int (buf
[16]) << 0;
1432 l
|= itoa64_to_int (buf
[17]) << 6;
1433 l
|= itoa64_to_int (buf
[18]) << 12;
1434 l
|= itoa64_to_int (buf
[19]) << 18;
1436 digest
[14] = (l
>> 0) & 0xff;
1437 digest
[13] = (l
>> 8) & 0xff;
1438 digest
[12] = (l
>> 16) & 0xff;
1440 l
= itoa64_to_int (buf
[20]) << 0;
1441 l
|= itoa64_to_int (buf
[21]) << 6;
1442 l
|= itoa64_to_int (buf
[22]) << 12;
1443 l
|= itoa64_to_int (buf
[23]) << 18;
1445 digest
[17] = (l
>> 0) & 0xff;
1446 digest
[16] = (l
>> 8) & 0xff;
1447 digest
[15] = (l
>> 16) & 0xff;
1449 l
= itoa64_to_int (buf
[24]) << 0;
1450 l
|= itoa64_to_int (buf
[25]) << 6;
1451 l
|= itoa64_to_int (buf
[26]) << 12;
1452 l
|= itoa64_to_int (buf
[27]) << 18;
1454 digest
[20] = (l
>> 0) & 0xff;
1455 digest
[19] = (l
>> 8) & 0xff;
1456 digest
[18] = (l
>> 16) & 0xff;
1458 l
= itoa64_to_int (buf
[28]) << 0;
1459 l
|= itoa64_to_int (buf
[29]) << 6;
1460 l
|= itoa64_to_int (buf
[30]) << 12;
1461 l
|= itoa64_to_int (buf
[31]) << 18;
1463 digest
[23] = (l
>> 0) & 0xff;
1464 digest
[22] = (l
>> 8) & 0xff;
1465 digest
[21] = (l
>> 16) & 0xff;
1467 l
= itoa64_to_int (buf
[32]) << 0;
1468 l
|= itoa64_to_int (buf
[33]) << 6;
1469 l
|= itoa64_to_int (buf
[34]) << 12;
1470 l
|= itoa64_to_int (buf
[35]) << 18;
1472 digest
[26] = (l
>> 0) & 0xff;
1473 digest
[25] = (l
>> 8) & 0xff;
1474 digest
[24] = (l
>> 16) & 0xff;
1476 l
= itoa64_to_int (buf
[36]) << 0;
1477 l
|= itoa64_to_int (buf
[37]) << 6;
1478 l
|= itoa64_to_int (buf
[38]) << 12;
1479 l
|= itoa64_to_int (buf
[39]) << 18;
1481 digest
[29] = (l
>> 0) & 0xff;
1482 digest
[28] = (l
>> 8) & 0xff;
1483 digest
[27] = (l
>> 16) & 0xff;
1485 l
= itoa64_to_int (buf
[40]) << 0;
1486 l
|= itoa64_to_int (buf
[41]) << 6;
1487 l
|= itoa64_to_int (buf
[42]) << 12;
1489 //digest[32] = (l >> 0) & 0xff;
1490 digest
[31] = (l
>> 8) & 0xff;
1491 digest
[30] = (l
>> 16) & 0xff;
1494 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1498 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1500 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1507 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1514 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[11] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1521 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[15] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1528 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[19] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1535 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[23] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1542 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[27] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1549 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[31] = int_to_itoa64 (l
& 0x3f);
1554 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1556 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1559 buf
[35] = int_to_itoa64 (l
& 0x3f);
1561 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1563 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1564 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1565 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1566 buf
[39] = int_to_itoa64 (l
& 0x3f);
1568 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1570 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1571 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1572 buf
[42] = int_to_itoa64 (l
& 0x3f);
1575 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1579 l
= itoa64_to_int (buf
[ 0]) << 0;
1580 l
|= itoa64_to_int (buf
[ 1]) << 6;
1581 l
|= itoa64_to_int (buf
[ 2]) << 12;
1582 l
|= itoa64_to_int (buf
[ 3]) << 18;
1584 digest
[ 2] = (l
>> 0) & 0xff;
1585 digest
[ 1] = (l
>> 8) & 0xff;
1586 digest
[ 0] = (l
>> 16) & 0xff;
1588 l
= itoa64_to_int (buf
[ 4]) << 0;
1589 l
|= itoa64_to_int (buf
[ 5]) << 6;
1590 l
|= itoa64_to_int (buf
[ 6]) << 12;
1591 l
|= itoa64_to_int (buf
[ 7]) << 18;
1593 digest
[ 5] = (l
>> 0) & 0xff;
1594 digest
[ 4] = (l
>> 8) & 0xff;
1595 digest
[ 3] = (l
>> 16) & 0xff;
1597 l
= itoa64_to_int (buf
[ 8]) << 0;
1598 l
|= itoa64_to_int (buf
[ 9]) << 6;
1599 l
|= itoa64_to_int (buf
[10]) << 12;
1600 l
|= itoa64_to_int (buf
[11]) << 18;
1602 digest
[ 8] = (l
>> 0) & 0xff;
1603 digest
[ 7] = (l
>> 8) & 0xff;
1604 digest
[ 6] = (l
>> 16) & 0xff;
1606 l
= itoa64_to_int (buf
[12]) << 0;
1607 l
|= itoa64_to_int (buf
[13]) << 6;
1608 l
|= itoa64_to_int (buf
[14]) << 12;
1609 l
|= itoa64_to_int (buf
[15]) << 18;
1611 digest
[11] = (l
>> 0) & 0xff;
1612 digest
[10] = (l
>> 8) & 0xff;
1613 digest
[ 9] = (l
>> 16) & 0xff;
1615 l
= itoa64_to_int (buf
[16]) << 0;
1616 l
|= itoa64_to_int (buf
[17]) << 6;
1617 l
|= itoa64_to_int (buf
[18]) << 12;
1618 l
|= itoa64_to_int (buf
[19]) << 18;
1620 digest
[14] = (l
>> 0) & 0xff;
1621 digest
[13] = (l
>> 8) & 0xff;
1622 digest
[12] = (l
>> 16) & 0xff;
1624 l
= itoa64_to_int (buf
[20]) << 0;
1625 l
|= itoa64_to_int (buf
[21]) << 6;
1626 l
|= itoa64_to_int (buf
[22]) << 12;
1627 l
|= itoa64_to_int (buf
[23]) << 18;
1629 digest
[17] = (l
>> 0) & 0xff;
1630 digest
[16] = (l
>> 8) & 0xff;
1631 digest
[15] = (l
>> 16) & 0xff;
1633 l
= itoa64_to_int (buf
[24]) << 0;
1634 l
|= itoa64_to_int (buf
[25]) << 6;
1635 l
|= itoa64_to_int (buf
[26]) << 12;
1636 l
|= itoa64_to_int (buf
[27]) << 18;
1638 digest
[20] = (l
>> 0) & 0xff;
1639 digest
[19] = (l
>> 8) & 0xff;
1640 digest
[18] = (l
>> 16) & 0xff;
1642 l
= itoa64_to_int (buf
[28]) << 0;
1643 l
|= itoa64_to_int (buf
[29]) << 6;
1644 l
|= itoa64_to_int (buf
[30]) << 12;
1645 l
|= itoa64_to_int (buf
[31]) << 18;
1647 digest
[23] = (l
>> 0) & 0xff;
1648 digest
[22] = (l
>> 8) & 0xff;
1649 digest
[21] = (l
>> 16) & 0xff;
1651 l
= itoa64_to_int (buf
[32]) << 0;
1652 l
|= itoa64_to_int (buf
[33]) << 6;
1653 l
|= itoa64_to_int (buf
[34]) << 12;
1654 l
|= itoa64_to_int (buf
[35]) << 18;
1656 digest
[26] = (l
>> 0) & 0xff;
1657 digest
[25] = (l
>> 8) & 0xff;
1658 digest
[24] = (l
>> 16) & 0xff;
1660 l
= itoa64_to_int (buf
[36]) << 0;
1661 l
|= itoa64_to_int (buf
[37]) << 6;
1662 l
|= itoa64_to_int (buf
[38]) << 12;
1663 l
|= itoa64_to_int (buf
[39]) << 18;
1665 digest
[29] = (l
>> 0) & 0xff;
1666 digest
[28] = (l
>> 8) & 0xff;
1667 digest
[27] = (l
>> 16) & 0xff;
1669 l
= itoa64_to_int (buf
[40]) << 0;
1670 l
|= itoa64_to_int (buf
[41]) << 6;
1671 l
|= itoa64_to_int (buf
[42]) << 12;
1672 l
|= itoa64_to_int (buf
[43]) << 18;
1674 digest
[32] = (l
>> 0) & 0xff;
1675 digest
[31] = (l
>> 8) & 0xff;
1676 digest
[30] = (l
>> 16) & 0xff;
1678 l
= itoa64_to_int (buf
[44]) << 0;
1679 l
|= itoa64_to_int (buf
[45]) << 6;
1680 l
|= itoa64_to_int (buf
[46]) << 12;
1681 l
|= itoa64_to_int (buf
[47]) << 18;
1683 digest
[35] = (l
>> 0) & 0xff;
1684 digest
[34] = (l
>> 8) & 0xff;
1685 digest
[33] = (l
>> 16) & 0xff;
1687 l
= itoa64_to_int (buf
[48]) << 0;
1688 l
|= itoa64_to_int (buf
[49]) << 6;
1689 l
|= itoa64_to_int (buf
[50]) << 12;
1690 l
|= itoa64_to_int (buf
[51]) << 18;
1692 digest
[38] = (l
>> 0) & 0xff;
1693 digest
[37] = (l
>> 8) & 0xff;
1694 digest
[36] = (l
>> 16) & 0xff;
1696 l
= itoa64_to_int (buf
[52]) << 0;
1697 l
|= itoa64_to_int (buf
[53]) << 6;
1698 l
|= itoa64_to_int (buf
[54]) << 12;
1699 l
|= itoa64_to_int (buf
[55]) << 18;
1701 digest
[41] = (l
>> 0) & 0xff;
1702 digest
[40] = (l
>> 8) & 0xff;
1703 digest
[39] = (l
>> 16) & 0xff;
1705 l
= itoa64_to_int (buf
[56]) << 0;
1706 l
|= itoa64_to_int (buf
[57]) << 6;
1707 l
|= itoa64_to_int (buf
[58]) << 12;
1708 l
|= itoa64_to_int (buf
[59]) << 18;
1710 digest
[44] = (l
>> 0) & 0xff;
1711 digest
[43] = (l
>> 8) & 0xff;
1712 digest
[42] = (l
>> 16) & 0xff;
1714 l
= itoa64_to_int (buf
[60]) << 0;
1715 l
|= itoa64_to_int (buf
[61]) << 6;
1716 l
|= itoa64_to_int (buf
[62]) << 12;
1717 l
|= itoa64_to_int (buf
[63]) << 18;
1719 digest
[47] = (l
>> 0) & 0xff;
1720 digest
[46] = (l
>> 8) & 0xff;
1721 digest
[45] = (l
>> 16) & 0xff;
1723 l
= itoa64_to_int (buf
[64]) << 0;
1724 l
|= itoa64_to_int (buf
[65]) << 6;
1725 l
|= itoa64_to_int (buf
[66]) << 12;
1726 l
|= itoa64_to_int (buf
[67]) << 18;
1728 digest
[50] = (l
>> 0) & 0xff;
1729 digest
[49] = (l
>> 8) & 0xff;
1730 digest
[48] = (l
>> 16) & 0xff;
1732 l
= itoa64_to_int (buf
[68]) << 0;
1733 l
|= itoa64_to_int (buf
[69]) << 6;
1734 l
|= itoa64_to_int (buf
[70]) << 12;
1735 l
|= itoa64_to_int (buf
[71]) << 18;
1737 digest
[53] = (l
>> 0) & 0xff;
1738 digest
[52] = (l
>> 8) & 0xff;
1739 digest
[51] = (l
>> 16) & 0xff;
1741 l
= itoa64_to_int (buf
[72]) << 0;
1742 l
|= itoa64_to_int (buf
[73]) << 6;
1743 l
|= itoa64_to_int (buf
[74]) << 12;
1744 l
|= itoa64_to_int (buf
[75]) << 18;
1746 digest
[56] = (l
>> 0) & 0xff;
1747 digest
[55] = (l
>> 8) & 0xff;
1748 digest
[54] = (l
>> 16) & 0xff;
1750 l
= itoa64_to_int (buf
[76]) << 0;
1751 l
|= itoa64_to_int (buf
[77]) << 6;
1752 l
|= itoa64_to_int (buf
[78]) << 12;
1753 l
|= itoa64_to_int (buf
[79]) << 18;
1755 digest
[59] = (l
>> 0) & 0xff;
1756 digest
[58] = (l
>> 8) & 0xff;
1757 digest
[57] = (l
>> 16) & 0xff;
1759 l
= itoa64_to_int (buf
[80]) << 0;
1760 l
|= itoa64_to_int (buf
[81]) << 6;
1761 l
|= itoa64_to_int (buf
[82]) << 12;
1762 l
|= itoa64_to_int (buf
[83]) << 18;
1764 digest
[62] = (l
>> 0) & 0xff;
1765 digest
[61] = (l
>> 8) & 0xff;
1766 digest
[60] = (l
>> 16) & 0xff;
1768 l
= itoa64_to_int (buf
[84]) << 0;
1769 l
|= itoa64_to_int (buf
[85]) << 6;
1771 digest
[63] = (l
>> 16) & 0xff;
1774 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1778 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1780 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1787 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1794 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[11] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1801 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[15] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1808 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[19] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1815 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[23] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1822 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[27] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1829 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[31] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1836 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[35] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1843 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[39] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1850 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[43] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1857 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[47] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1864 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[51] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1871 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[55] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1878 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[59] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1885 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[63] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1892 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[67] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1899 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[71] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1906 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[75] = int_to_itoa64 (l
& 0x3f);
1911 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1913 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1915 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 buf
[79] = int_to_itoa64 (l
& 0x3f);
1918 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1920 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1921 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1922 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1923 buf
[83] = int_to_itoa64 (l
& 0x3f);
1925 l
= 0 | 0 | (digest
[63] << 16);
1927 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1928 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1931 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1935 l
= itoa64_to_int (buf
[ 0]) << 0;
1936 l
|= itoa64_to_int (buf
[ 1]) << 6;
1937 l
|= itoa64_to_int (buf
[ 2]) << 12;
1938 l
|= itoa64_to_int (buf
[ 3]) << 18;
1940 digest
[ 0] = (l
>> 16) & 0xff;
1941 digest
[10] = (l
>> 8) & 0xff;
1942 digest
[20] = (l
>> 0) & 0xff;
1944 l
= itoa64_to_int (buf
[ 4]) << 0;
1945 l
|= itoa64_to_int (buf
[ 5]) << 6;
1946 l
|= itoa64_to_int (buf
[ 6]) << 12;
1947 l
|= itoa64_to_int (buf
[ 7]) << 18;
1949 digest
[21] = (l
>> 16) & 0xff;
1950 digest
[ 1] = (l
>> 8) & 0xff;
1951 digest
[11] = (l
>> 0) & 0xff;
1953 l
= itoa64_to_int (buf
[ 8]) << 0;
1954 l
|= itoa64_to_int (buf
[ 9]) << 6;
1955 l
|= itoa64_to_int (buf
[10]) << 12;
1956 l
|= itoa64_to_int (buf
[11]) << 18;
1958 digest
[12] = (l
>> 16) & 0xff;
1959 digest
[22] = (l
>> 8) & 0xff;
1960 digest
[ 2] = (l
>> 0) & 0xff;
1962 l
= itoa64_to_int (buf
[12]) << 0;
1963 l
|= itoa64_to_int (buf
[13]) << 6;
1964 l
|= itoa64_to_int (buf
[14]) << 12;
1965 l
|= itoa64_to_int (buf
[15]) << 18;
1967 digest
[ 3] = (l
>> 16) & 0xff;
1968 digest
[13] = (l
>> 8) & 0xff;
1969 digest
[23] = (l
>> 0) & 0xff;
1971 l
= itoa64_to_int (buf
[16]) << 0;
1972 l
|= itoa64_to_int (buf
[17]) << 6;
1973 l
|= itoa64_to_int (buf
[18]) << 12;
1974 l
|= itoa64_to_int (buf
[19]) << 18;
1976 digest
[24] = (l
>> 16) & 0xff;
1977 digest
[ 4] = (l
>> 8) & 0xff;
1978 digest
[14] = (l
>> 0) & 0xff;
1980 l
= itoa64_to_int (buf
[20]) << 0;
1981 l
|= itoa64_to_int (buf
[21]) << 6;
1982 l
|= itoa64_to_int (buf
[22]) << 12;
1983 l
|= itoa64_to_int (buf
[23]) << 18;
1985 digest
[15] = (l
>> 16) & 0xff;
1986 digest
[25] = (l
>> 8) & 0xff;
1987 digest
[ 5] = (l
>> 0) & 0xff;
1989 l
= itoa64_to_int (buf
[24]) << 0;
1990 l
|= itoa64_to_int (buf
[25]) << 6;
1991 l
|= itoa64_to_int (buf
[26]) << 12;
1992 l
|= itoa64_to_int (buf
[27]) << 18;
1994 digest
[ 6] = (l
>> 16) & 0xff;
1995 digest
[16] = (l
>> 8) & 0xff;
1996 digest
[26] = (l
>> 0) & 0xff;
1998 l
= itoa64_to_int (buf
[28]) << 0;
1999 l
|= itoa64_to_int (buf
[29]) << 6;
2000 l
|= itoa64_to_int (buf
[30]) << 12;
2001 l
|= itoa64_to_int (buf
[31]) << 18;
2003 digest
[27] = (l
>> 16) & 0xff;
2004 digest
[ 7] = (l
>> 8) & 0xff;
2005 digest
[17] = (l
>> 0) & 0xff;
2007 l
= itoa64_to_int (buf
[32]) << 0;
2008 l
|= itoa64_to_int (buf
[33]) << 6;
2009 l
|= itoa64_to_int (buf
[34]) << 12;
2010 l
|= itoa64_to_int (buf
[35]) << 18;
2012 digest
[18] = (l
>> 16) & 0xff;
2013 digest
[28] = (l
>> 8) & 0xff;
2014 digest
[ 8] = (l
>> 0) & 0xff;
2016 l
= itoa64_to_int (buf
[36]) << 0;
2017 l
|= itoa64_to_int (buf
[37]) << 6;
2018 l
|= itoa64_to_int (buf
[38]) << 12;
2019 l
|= itoa64_to_int (buf
[39]) << 18;
2021 digest
[ 9] = (l
>> 16) & 0xff;
2022 digest
[19] = (l
>> 8) & 0xff;
2023 digest
[29] = (l
>> 0) & 0xff;
2025 l
= itoa64_to_int (buf
[40]) << 0;
2026 l
|= itoa64_to_int (buf
[41]) << 6;
2027 l
|= itoa64_to_int (buf
[42]) << 12;
2029 digest
[31] = (l
>> 8) & 0xff;
2030 digest
[30] = (l
>> 0) & 0xff;
2033 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2037 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2039 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2046 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2053 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2060 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2067 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2074 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2081 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2088 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2095 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2098 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2100 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2102 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2103 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2104 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2105 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2107 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2109 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2110 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2111 buf
[42] = int_to_itoa64 (l
& 0x3f);
2114 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2118 l
= itoa64_to_int (buf
[ 0]) << 0;
2119 l
|= itoa64_to_int (buf
[ 1]) << 6;
2120 l
|= itoa64_to_int (buf
[ 2]) << 12;
2121 l
|= itoa64_to_int (buf
[ 3]) << 18;
2123 digest
[ 0] = (l
>> 0) & 0xff;
2124 digest
[ 1] = (l
>> 8) & 0xff;
2125 digest
[ 2] = (l
>> 16) & 0xff;
2127 l
= itoa64_to_int (buf
[ 4]) << 0;
2128 l
|= itoa64_to_int (buf
[ 5]) << 6;
2129 l
|= itoa64_to_int (buf
[ 6]) << 12;
2130 l
|= itoa64_to_int (buf
[ 7]) << 18;
2132 digest
[ 3] = (l
>> 0) & 0xff;
2133 digest
[ 4] = (l
>> 8) & 0xff;
2134 digest
[ 5] = (l
>> 16) & 0xff;
2136 l
= itoa64_to_int (buf
[ 8]) << 0;
2137 l
|= itoa64_to_int (buf
[ 9]) << 6;
2138 l
|= itoa64_to_int (buf
[10]) << 12;
2139 l
|= itoa64_to_int (buf
[11]) << 18;
2141 digest
[ 6] = (l
>> 0) & 0xff;
2142 digest
[ 7] = (l
>> 8) & 0xff;
2143 digest
[ 8] = (l
>> 16) & 0xff;
2145 l
= itoa64_to_int (buf
[12]) << 0;
2146 l
|= itoa64_to_int (buf
[13]) << 6;
2147 l
|= itoa64_to_int (buf
[14]) << 12;
2148 l
|= itoa64_to_int (buf
[15]) << 18;
2150 digest
[ 9] = (l
>> 0) & 0xff;
2151 digest
[10] = (l
>> 8) & 0xff;
2152 digest
[11] = (l
>> 16) & 0xff;
2154 l
= itoa64_to_int (buf
[16]) << 0;
2155 l
|= itoa64_to_int (buf
[17]) << 6;
2156 l
|= itoa64_to_int (buf
[18]) << 12;
2157 l
|= itoa64_to_int (buf
[19]) << 18;
2159 digest
[12] = (l
>> 0) & 0xff;
2160 digest
[13] = (l
>> 8) & 0xff;
2161 digest
[14] = (l
>> 16) & 0xff;
2163 l
= itoa64_to_int (buf
[20]) << 0;
2164 l
|= itoa64_to_int (buf
[21]) << 6;
2165 l
|= itoa64_to_int (buf
[22]) << 12;
2166 l
|= itoa64_to_int (buf
[23]) << 18;
2168 digest
[15] = (l
>> 0) & 0xff;
2169 digest
[16] = (l
>> 8) & 0xff;
2170 digest
[17] = (l
>> 16) & 0xff;
2172 l
= itoa64_to_int (buf
[24]) << 0;
2173 l
|= itoa64_to_int (buf
[25]) << 6;
2174 l
|= itoa64_to_int (buf
[26]) << 12;
2175 l
|= itoa64_to_int (buf
[27]) << 18;
2177 digest
[18] = (l
>> 0) & 0xff;
2178 digest
[19] = (l
>> 8) & 0xff;
2179 digest
[20] = (l
>> 16) & 0xff;
2181 l
= itoa64_to_int (buf
[28]) << 0;
2182 l
|= itoa64_to_int (buf
[29]) << 6;
2183 l
|= itoa64_to_int (buf
[30]) << 12;
2184 l
|= itoa64_to_int (buf
[31]) << 18;
2186 digest
[21] = (l
>> 0) & 0xff;
2187 digest
[22] = (l
>> 8) & 0xff;
2188 digest
[23] = (l
>> 16) & 0xff;
2190 l
= itoa64_to_int (buf
[32]) << 0;
2191 l
|= itoa64_to_int (buf
[33]) << 6;
2192 l
|= itoa64_to_int (buf
[34]) << 12;
2193 l
|= itoa64_to_int (buf
[35]) << 18;
2195 digest
[24] = (l
>> 0) & 0xff;
2196 digest
[25] = (l
>> 8) & 0xff;
2197 digest
[26] = (l
>> 16) & 0xff;
2199 l
= itoa64_to_int (buf
[36]) << 0;
2200 l
|= itoa64_to_int (buf
[37]) << 6;
2201 l
|= itoa64_to_int (buf
[38]) << 12;
2202 l
|= itoa64_to_int (buf
[39]) << 18;
2204 digest
[27] = (l
>> 0) & 0xff;
2205 digest
[28] = (l
>> 8) & 0xff;
2206 digest
[29] = (l
>> 16) & 0xff;
2208 l
= itoa64_to_int (buf
[40]) << 0;
2209 l
|= itoa64_to_int (buf
[41]) << 6;
2210 l
|= itoa64_to_int (buf
[42]) << 12;
2211 l
|= itoa64_to_int (buf
[43]) << 18;
2213 digest
[30] = (l
>> 0) & 0xff;
2214 digest
[31] = (l
>> 8) & 0xff;
2215 digest
[32] = (l
>> 16) & 0xff;
2250 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2254 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2256 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2263 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2270 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[11] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2277 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[15] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2284 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[19] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2291 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[23] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2298 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[27] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2305 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[31] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2312 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 buf
[35] = int_to_itoa64 (l
& 0x3f);
2317 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2319 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2320 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2321 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2322 buf
[39] = int_to_itoa64 (l
& 0x3f);
2324 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2326 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2327 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2328 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2329 //buf[43] = int_to_itoa64 (l & 0x3f);
2337 static struct termio savemodes
;
2338 static int havemodes
= 0;
2342 struct termio modmodes
;
2344 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2348 modmodes
= savemodes
;
2349 modmodes
.c_lflag
&= ~ICANON
;
2350 modmodes
.c_cc
[VMIN
] = 1;
2351 modmodes
.c_cc
[VTIME
] = 0;
2353 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2362 FD_SET (fileno (stdin
), &rfds
);
2369 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2371 if (retval
== 0) return 0;
2372 if (retval
== -1) return -1;
2379 if (!havemodes
) return 0;
2381 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2386 static struct termios savemodes
;
2387 static int havemodes
= 0;
2391 struct termios modmodes
;
2393 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2397 modmodes
= savemodes
;
2398 modmodes
.c_lflag
&= ~ICANON
;
2399 modmodes
.c_cc
[VMIN
] = 1;
2400 modmodes
.c_cc
[VTIME
] = 0;
2402 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2411 FD_SET (fileno (stdin
), &rfds
);
2418 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2420 if (retval
== 0) return 0;
2421 if (retval
== -1) return -1;
2428 if (!havemodes
) return 0;
2430 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2435 static DWORD saveMode
= 0;
2439 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2441 GetConsoleMode (stdinHandle
, &saveMode
);
2442 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2449 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2451 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2453 if (rc
== WAIT_TIMEOUT
) return 0;
2454 if (rc
== WAIT_ABANDONED
) return -1;
2455 if (rc
== WAIT_FAILED
) return -1;
2457 // The whole ReadConsoleInput () part is a workaround.
2458 // For some unknown reason, maybe a mingw bug, a random signal
2459 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2460 // Then it wants to read with getche () a keyboard input
2461 // which has never been made.
2463 INPUT_RECORD buf
[100];
2467 memset (buf
, 0, sizeof (buf
));
2469 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2471 FlushConsoleInputBuffer (stdinHandle
);
2473 for (uint i
= 0; i
< num
; i
++)
2475 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2477 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2479 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2481 return KeyEvent
.uChar
.AsciiChar
;
2489 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2491 SetConsoleMode (stdinHandle
, saveMode
);
2501 #define MSG_ENOMEM "Insufficient memory available"
2503 void *mycalloc (size_t nmemb
, size_t size
)
2505 void *p
= calloc (nmemb
, size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2517 void *mymalloc (size_t size
)
2519 void *p
= malloc (size
);
2523 log_error ("ERROR: %s", MSG_ENOMEM
);
2528 memset (p
, 0, size
);
2533 void myfree (void *ptr
)
2535 if (ptr
== NULL
) return;
2540 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2542 void *p
= realloc (ptr
, oldsz
+ add
);
2546 log_error ("ERROR: %s", MSG_ENOMEM
);
2551 memset ((char *) p
+ oldsz
, 0, add
);
2556 char *mystrdup (const char *s
)
2558 const size_t len
= strlen (s
);
2560 char *b
= (char *) mymalloc (len
+ 1);
2567 FILE *logfile_open (char *logfile
)
2569 FILE *fp
= fopen (logfile
, "ab");
2579 void logfile_close (FILE *fp
)
2581 if (fp
== stdout
) return;
2586 void logfile_append (const char *fmt
, ...)
2588 if (data
.logfile_disable
== 1) return;
2590 FILE *fp
= logfile_open (data
.logfile
);
2596 vfprintf (fp
, fmt
, ap
);
2607 int logfile_generate_id ()
2609 const int n
= rand ();
2618 char *logfile_generate_topid ()
2620 const int id
= logfile_generate_id ();
2622 char *topid
= (char *) mymalloc (1 + 16 + 1);
2624 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2629 char *logfile_generate_subid ()
2631 const int id
= logfile_generate_id ();
2633 char *subid
= (char *) mymalloc (1 + 16 + 1);
2635 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2645 void lock_file (FILE *fp
)
2649 memset (&lock
, 0, sizeof (struct flock
));
2651 lock
.l_type
= F_WRLCK
;
2652 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2656 log_error ("ERROR: Failed acquiring write lock: %s", strerror (errno
));
2663 void unlock_file (FILE *fp
)
2667 memset (&lock
, 0, sizeof (struct flock
));
2669 lock
.l_type
= F_UNLCK
;
2670 fcntl(fileno(fp
), F_SETLK
, &lock
);
2677 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2679 FlushFileBuffers (h
);
2689 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2691 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2693 if (iNumberAdapters
== 0)
2695 log_info ("WARN: No ADL adapters found.");
2704 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2706 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2707 ADLODParameters lpOdParameters;
2709 lpOdParameters.iSize = sizeof (ADLODParameters);
2710 size_t plevels_size = 0;
2712 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2714 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2715 __func__, iAdapterIndex,
2716 lpOdParameters.iNumberOfPerformanceLevels,
2717 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2718 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2720 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2722 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2724 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2726 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2728 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2729 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2730 __func__, iAdapterIndex, j,
2731 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2733 myfree (lpOdPerformanceLevels);
2739 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2741 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2743 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2745 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2747 return lpAdapterInfo
;
2750 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2754 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2758 log_info ("WARN: No NvAPI adapters found");
2766 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2770 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2772 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2774 // can be used to determine if the device by index matches the cuda device by index
2775 // char name[100]; memset (name, 0, sizeof (name));
2776 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2783 log_info ("WARN: No NVML adapters found");
2793 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2796 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2800 for (uint i = 0; i < num_adl_adapters; i++)
2802 int opencl_bus_num = hm_device[i].busid;
2803 int opencl_dev_num = hm_device[i].devid;
2805 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2813 if (idx >= DEVICES_MAX) return -1;
2818 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2820 for (uint i = 0; i < opencl_num_devices; i++)
2822 cl_device_topology_amd device_topology;
2824 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2826 hm_device[i].busid = device_topology.pcie.bus;
2827 hm_device[i].devid = device_topology.pcie.device;
2832 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2834 // basically bubble sort
2836 for (int i
= 0; i
< num_adl_adapters
; i
++)
2838 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2840 // get info of adapter [x]
2842 u32 adapter_index_x
= valid_adl_device_list
[j
];
2843 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2845 u32 bus_num_x
= info_x
.iBusNumber
;
2846 u32 dev_num_x
= info_x
.iDeviceNumber
;
2848 // get info of adapter [y]
2850 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2851 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2853 u32 bus_num_y
= info_y
.iBusNumber
;
2854 u32 dev_num_y
= info_y
.iDeviceNumber
;
2858 if (bus_num_y
< bus_num_x
)
2862 else if (bus_num_y
== bus_num_x
)
2864 if (dev_num_y
< dev_num_x
)
2872 u32 temp
= valid_adl_device_list
[j
+ 1];
2874 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2875 valid_adl_device_list
[j
+ 0] = temp
;
2881 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2883 *num_adl_adapters
= 0;
2885 u32
*adl_adapters
= NULL
;
2887 int *bus_numbers
= NULL
;
2888 int *device_numbers
= NULL
;
2890 for (int i
= 0; i
< iNumberAdapters
; i
++)
2892 AdapterInfo info
= lpAdapterInfo
[i
];
2894 if (strlen (info
.strUDID
) < 1) continue;
2897 if (info
.iVendorID
!= 1002) continue;
2899 if (info
.iVendorID
!= 0x1002) continue;
2902 if (info
.iBusNumber
< 0) continue;
2903 if (info
.iDeviceNumber
< 0) continue;
2907 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2909 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2916 if (found
) continue;
2918 // add it to the list
2920 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2922 adl_adapters
[*num_adl_adapters
] = i
;
2924 // rest is just bookkeeping
2926 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2927 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2929 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2930 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2932 (*num_adl_adapters
)++;
2935 myfree (bus_numbers
);
2936 myfree (device_numbers
);
2938 // sort the list by increasing bus id, device id number
2940 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2942 return adl_adapters
;
2945 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2947 // loop through all valid devices
2949 for (int i
= 0; i
< num_adl_adapters
; i
++)
2951 u32 adapter_index
= valid_adl_device_list
[i
];
2955 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2957 // unfortunately this doesn't work since bus id and dev id are not unique
2958 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2959 // if (opencl_device_index == -1) continue;
2961 int opencl_device_index
= i
;
2963 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2965 // get fanspeed info
2967 if (hm_device
[opencl_device_index
].od_version
== 5)
2969 ADLFanSpeedInfo FanSpeedInfo
;
2971 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2973 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2975 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2977 // check read and write capability in fanspeedinfo
2979 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2980 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2982 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2986 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2989 else // od_version == 6
2991 ADLOD6FanSpeedInfo faninfo
;
2993 memset (&faninfo
, 0, sizeof (faninfo
));
2995 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2997 // check read capability in fanspeedinfo
2999 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
3001 hm_device
[opencl_device_index
].fan_get_supported
= 1;
3005 hm_device
[opencl_device_index
].fan_get_supported
= 0;
3013 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3015 for (int i
= 0; i
< num_adl_adapters
; i
++)
3017 u32 adapter_index
= valid_adl_device_list
[i
];
3021 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3023 // get overdrive version
3025 int od_supported
= 0;
3029 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3031 // store the overdrive version in hm_device
3033 // unfortunately this doesn't work since bus id and dev id are not unique
3034 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3035 // if (opencl_device_index == -1) continue;
3037 int opencl_device_index
= i
;
3039 hm_device
[opencl_device_index
].od_version
= od_version
;
3045 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3047 for (int i
= 0; i
< num_adl_adapters
; i
++)
3049 u32 adapter_index
= valid_adl_device_list
[i
];
3053 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3055 // store the iAdapterIndex in hm_device
3057 // unfortunately this doesn't work since bus id and dev id are not unique
3058 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3059 // if (opencl_device_index == -1) continue;
3061 int opencl_device_index
= i
;
3063 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3066 return num_adl_adapters
;
3069 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3071 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3073 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3077 if (data
.hm_device
[device_id
].od_version
== 5)
3081 else if (data
.hm_device
[device_id
].od_version
== 6)
3083 int CurrentValue
= 0;
3084 int DefaultValue
= 0;
3086 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3088 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3090 return DefaultValue
;
3095 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3099 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3107 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3109 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3111 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3115 if (data
.hm_device
[device_id
].od_version
== 5)
3119 else if (data
.hm_device
[device_id
].od_version
== 6)
3126 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3130 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3138 int hm_get_temperature_with_device_id (const uint device_id
)
3140 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3142 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3146 if (data
.hm_device
[device_id
].od_version
== 5)
3148 ADLTemperature Temperature
;
3150 Temperature
.iSize
= sizeof (ADLTemperature
);
3152 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3154 return Temperature
.iTemperature
/ 1000;
3156 else if (data
.hm_device
[device_id
].od_version
== 6)
3158 int Temperature
= 0;
3160 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3162 return Temperature
/ 1000;
3167 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3169 int temperature
= 0;
3171 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3179 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3181 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3183 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3185 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3189 if (data
.hm_device
[device_id
].od_version
== 5)
3191 ADLFanSpeedValue lpFanSpeedValue
;
3193 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3195 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3196 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3198 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3200 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3202 else // od_version == 6
3209 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3218 int hm_get_fanspeed_with_device_id (const uint device_id
)
3220 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3222 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3224 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3228 if (data
.hm_device
[device_id
].od_version
== 5)
3230 ADLFanSpeedValue lpFanSpeedValue
;
3232 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3234 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3235 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3236 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3238 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3240 return lpFanSpeedValue
.iFanSpeed
;
3242 else // od_version == 6
3244 ADLOD6FanSpeedInfo faninfo
;
3246 memset (&faninfo
, 0, sizeof (faninfo
));
3248 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3250 return faninfo
.iFanSpeedPercent
;
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3259 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3268 int hm_get_buslanes_with_device_id (const uint device_id
)
3270 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3272 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3276 ADLPMActivity PMActivity
;
3278 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3280 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3282 return PMActivity
.iCurrentBusLanes
;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3288 unsigned int currLinkWidth
;
3290 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3292 return currLinkWidth
;
3298 int hm_get_utilization_with_device_id (const uint device_id
)
3300 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3306 ADLPMActivity PMActivity
;
3308 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3310 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3312 return PMActivity
.iActivityPercent
;
3316 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3318 nvmlUtilization_t utilization
;
3320 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3322 return utilization
.gpu
;
3328 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3330 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3332 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3336 ADLPMActivity PMActivity
;
3338 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3340 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3342 return PMActivity
.iMemoryClock
/ 100;
3346 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3350 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3358 int hm_get_corespeed_with_device_id (const uint device_id
)
3360 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3362 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3366 ADLPMActivity PMActivity
;
3368 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3370 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3372 return PMActivity
.iEngineClock
/ 100;
3376 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3380 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3388 int hm_get_throttle_with_device_id (const uint device_id
)
3390 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3392 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3397 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3399 unsigned long long clocksThrottleReasons
= 0;
3400 unsigned long long supportedThrottleReasons
= 0;
3402 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3403 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3405 clocksThrottleReasons
&= supportedThrottleReasons
;
3406 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonGpuIdle
;
3407 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonApplicationsClocksSetting
;
3408 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3410 if (data
.kernel_power_final
)
3412 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonHwSlowdown
;
3415 return (clocksThrottleReasons
!= nvmlClocksThrottleReasonNone
);
3421 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3423 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
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)
3485 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3487 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3489 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3490 CoolerLevels
.Levels
[0].Policy
= fanpolicy
;
3492 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3501 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3503 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3505 if (data
.hm_xnvctrl
)
3507 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3516 #endif // HAVE_HWMON
3522 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3524 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3526 if (css_cnt
> SP_PW_MAX
)
3528 log_error ("ERROR: Mask length is too long");
3533 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3535 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3537 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3538 uint cs_len
= css
[css_pos
].cs_len
;
3540 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3542 uint c
= cs_buf
[cs_pos
] & 0xff;
3549 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3551 cs_t
*cs
= &css
[css_cnt
];
3553 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3555 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3559 for (i
= 0; i
< cs
->cs_len
; i
++)
3561 const uint u
= cs
->cs_buf
[i
];
3566 for (i
= 0; i
< in_len
; i
++)
3568 uint u
= in_buf
[i
] & 0xff;
3570 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3572 if (css_uniq
[u
] == 1) continue;
3576 cs
->cs_buf
[cs
->cs_len
] = u
;
3584 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3588 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3590 uint p0
= in_buf
[in_pos
] & 0xff;
3592 if (interpret
== 1 && p0
== '?')
3596 if (in_pos
== in_len
) break;
3598 uint p1
= in_buf
[in_pos
] & 0xff;
3602 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3604 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3606 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3608 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3610 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3612 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3614 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3615 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3617 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3618 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3620 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3621 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3623 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3624 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3626 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3628 default: log_error ("Syntax error: %s", in_buf
);
3634 if (data
.hex_charset
)
3638 if (in_pos
== in_len
)
3640 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3645 uint p1
= in_buf
[in_pos
] & 0xff;
3647 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3649 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3656 chr
= hex_convert (p1
) << 0;
3657 chr
|= hex_convert (p0
) << 4;
3659 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3665 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3671 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3675 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3677 sum
*= css
[css_pos
].cs_len
;
3683 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3685 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3690 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3692 char p0
= mask_buf
[mask_pos
];
3698 if (mask_pos
== mask_len
) break;
3700 char p1
= mask_buf
[mask_pos
];
3706 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3708 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3710 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3712 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3714 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3716 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3718 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3719 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3721 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3722 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3724 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3725 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3727 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3728 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3730 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3732 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3738 if (data
.hex_charset
)
3742 // if there is no 2nd hex character, show an error:
3744 if (mask_pos
== mask_len
)
3746 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3751 char p1
= mask_buf
[mask_pos
];
3753 // if they are not valid hex character, show an error:
3755 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3757 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3764 chr
|= hex_convert (p1
) << 0;
3765 chr
|= hex_convert (p0
) << 4;
3767 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3773 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3780 log_error ("ERROR: Invalid mask length (0)");
3790 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3792 for (int i
= 0; i
< css_cnt
; i
++)
3794 uint len
= css
[i
].cs_len
;
3795 u64 next
= val
/ len
;
3796 uint pos
= val
% len
;
3797 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3802 void mp_cut_at (char *mask
, uint max
)
3806 uint mask_len
= strlen (mask
);
3808 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3810 if (mask
[i
] == '?') i
++;
3816 void mp_setup_sys (cs_t
*mp_sys
)
3820 uint donec
[CHARSIZ
] = { 0 };
3822 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3823 mp_sys
[0].cs_buf
[pos
++] = chr
;
3824 mp_sys
[0].cs_len
= pos
; }
3826 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3827 mp_sys
[1].cs_buf
[pos
++] = chr
;
3828 mp_sys
[1].cs_len
= pos
; }
3830 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3831 mp_sys
[2].cs_buf
[pos
++] = chr
;
3832 mp_sys
[2].cs_len
= pos
; }
3834 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3835 mp_sys
[3].cs_buf
[pos
++] = chr
;
3836 mp_sys
[3].cs_len
= pos
; }
3838 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3839 mp_sys
[4].cs_len
= pos
; }
3841 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3842 mp_sys
[5].cs_len
= pos
; }
3845 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3847 FILE *fp
= fopen (buf
, "rb");
3849 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3851 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3855 char mp_file
[1024] = { 0 };
3857 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3861 len
= in_superchop (mp_file
);
3865 log_info ("WARNING: Charset file corrupted");
3867 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3871 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3876 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3878 mp_usr
[index
].cs_len
= 0;
3880 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3883 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3885 char *new_mask_buf
= (char *) mymalloc (256);
3891 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3893 if (css_pos
== len
) break;
3895 char p0
= mask_buf
[mask_pos
];
3897 new_mask_buf
[mask_pos
] = p0
;
3903 if (mask_pos
== mask_len
) break;
3905 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3909 if (data
.hex_charset
)
3913 if (mask_pos
== mask_len
)
3915 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3920 char p1
= mask_buf
[mask_pos
];
3922 // if they are not valid hex character, show an error:
3924 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3926 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3931 new_mask_buf
[mask_pos
] = p1
;
3936 if (css_pos
== len
) return (new_mask_buf
);
3938 myfree (new_mask_buf
);
3947 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3953 for (i
= start
; i
< stop
; i
++)
3955 sum
*= root_css_buf
[i
].cs_len
;
3961 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3965 cs_t
*cs
= &root_css_buf
[start
];
3969 for (i
= start
; i
< stop
; i
++)
3971 const u64 m
= v
% cs
->cs_len
;
3972 const u64 d
= v
/ cs
->cs_len
;
3976 const uint k
= cs
->cs_buf
[m
];
3978 pw_buf
[i
- start
] = (char) k
;
3980 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3984 int sp_comp_val (const void *p1
, const void *p2
)
3986 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3987 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3989 return b2
->val
- b1
->val
;
3992 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
)
3999 * Initialize hcstats
4002 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4004 u64
*root_stats_ptr
= root_stats_buf
;
4006 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4008 for (i
= 0; i
< SP_PW_MAX
; i
++)
4010 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4012 root_stats_ptr
+= CHARSIZ
;
4015 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4017 u64
*markov_stats_ptr
= markov_stats_buf
;
4019 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4021 for (i
= 0; i
< SP_PW_MAX
; i
++)
4023 for (j
= 0; j
< CHARSIZ
; j
++)
4025 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4027 markov_stats_ptr
+= CHARSIZ
;
4037 char hcstat_tmp
[256] = { 0 };
4039 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4041 hcstat
= hcstat_tmp
;
4044 FILE *fd
= fopen (hcstat
, "rb");
4048 log_error ("%s: %s", hcstat
, strerror (errno
));
4053 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4055 log_error ("%s: Could not load data", hcstat
);
4062 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4064 log_error ("%s: Could not load data", hcstat
);
4074 * Markov modifier of hcstat_table on user request
4079 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4080 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4085 /* Add all stats to first position */
4087 for (i
= 1; i
< SP_PW_MAX
; i
++)
4089 u64
*out
= root_stats_buf_by_pos
[0];
4090 u64
*in
= root_stats_buf_by_pos
[i
];
4092 for (j
= 0; j
< CHARSIZ
; j
++)
4098 for (i
= 1; i
< SP_PW_MAX
; i
++)
4100 u64
*out
= markov_stats_buf_by_key
[0][0];
4101 u64
*in
= markov_stats_buf_by_key
[i
][0];
4103 for (j
= 0; j
< CHARSIZ
; j
++)
4105 for (k
= 0; k
< CHARSIZ
; k
++)
4112 /* copy them to all pw_positions */
4114 for (i
= 1; i
< SP_PW_MAX
; i
++)
4116 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4119 for (i
= 1; i
< SP_PW_MAX
; i
++)
4121 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4129 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4131 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4133 for (i
= 0; i
< SP_PW_MAX
; i
++)
4135 root_table_buf_by_pos
[i
] = root_table_ptr
;
4137 root_table_ptr
+= CHARSIZ
;
4140 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4142 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4144 for (i
= 0; i
< SP_PW_MAX
; i
++)
4146 for (j
= 0; j
< CHARSIZ
; j
++)
4148 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4150 markov_table_ptr
+= CHARSIZ
;
4155 * Convert hcstat to tables
4158 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4160 uint key
= i
% CHARSIZ
;
4162 root_table_buf
[i
].key
= key
;
4163 root_table_buf
[i
].val
= root_stats_buf
[i
];
4166 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4168 uint key
= i
% CHARSIZ
;
4170 markov_table_buf
[i
].key
= key
;
4171 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4174 myfree (root_stats_buf
);
4175 myfree (markov_stats_buf
);
4181 for (i
= 0; i
< SP_PW_MAX
; i
++)
4183 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4186 for (i
= 0; i
< SP_PW_MAX
; i
++)
4188 for (j
= 0; j
< CHARSIZ
; j
++)
4190 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4195 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
])
4198 * Convert tables to css
4201 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4203 uint pw_pos
= i
/ CHARSIZ
;
4205 cs_t
*cs
= &root_css_buf
[pw_pos
];
4207 if (cs
->cs_len
== threshold
) continue;
4209 uint key
= root_table_buf
[i
].key
;
4211 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4213 cs
->cs_buf
[cs
->cs_len
] = key
;
4219 * Convert table to css
4222 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4224 uint c
= i
/ CHARSIZ
;
4226 cs_t
*cs
= &markov_css_buf
[c
];
4228 if (cs
->cs_len
== threshold
) continue;
4230 uint pw_pos
= c
/ CHARSIZ
;
4232 uint key
= markov_table_buf
[i
].key
;
4234 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4236 cs
->cs_buf
[cs
->cs_len
] = key
;
4242 for (uint i = 0; i < 8; i++)
4244 for (uint j = 0x20; j < 0x80; j++)
4246 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4248 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4250 for (uint k = 0; k < 10; k++)
4252 printf (" %u\n", ptr->cs_buf[k]);
4259 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4261 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4263 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4273 for (uint j
= 1; j
< CHARSIZ
; j
++)
4283 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4285 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4287 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4289 out
+= CHARSIZ
* CHARSIZ
;
4290 in
+= CHARSIZ
* CHARSIZ
;
4292 for (uint j
= 0; j
< CHARSIZ
; j
++)
4299 for (uint k
= 1; k
< CHARSIZ
; k
++)
4311 * mixed shared functions
4314 void dump_hex (const u8
*s
, const int sz
)
4316 for (int i
= 0; i
< sz
; i
++)
4318 log_info_nn ("%02x ", s
[i
]);
4324 void usage_mini_print (const char *progname
)
4326 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4329 void usage_big_print (const char *progname
)
4331 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4334 char *get_exec_path ()
4336 int exec_path_len
= 1024;
4338 char *exec_path
= (char *) mymalloc (exec_path_len
);
4342 char tmp
[32] = { 0 };
4344 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4346 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4350 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4354 uint size
= exec_path_len
;
4356 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4358 log_error("! executable path buffer too small\n");
4363 const int len
= strlen (exec_path
);
4366 #error Your Operating System is not supported or detected
4374 char *get_install_dir (const char *progname
)
4376 char *install_dir
= mystrdup (progname
);
4377 char *last_slash
= NULL
;
4379 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4383 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4389 install_dir
[0] = '.';
4393 return (install_dir
);
4396 char *get_profile_dir (const char *homedir
)
4398 #define DOT_HASHCAT ".hashcat"
4400 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4402 char *profile_dir
= (char *) mymalloc (len
+ 1);
4404 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4409 char *get_session_dir (const char *profile_dir
)
4411 #define SESSIONS_FOLDER "sessions"
4413 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4415 char *session_dir
= (char *) mymalloc (len
+ 1);
4417 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4422 uint
count_lines (FILE *fd
)
4426 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4432 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4434 if (nread
< 1) continue;
4438 for (i
= 0; i
< nread
; i
++)
4440 if (prev
== '\n') cnt
++;
4451 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4455 FILE *fd
= fopen (filename
, "rb");
4459 log_error ("%s: %s", filename
, strerror (errno
));
4464 #define MAX_KEY_SIZE (1024 * 1024)
4466 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4468 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4474 for (int fpos
= 0; fpos
< nread
; fpos
++)
4476 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4478 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4479 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4480 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4481 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4483 if (kpos
>= 64) kpos
= 0;
4490 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4494 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4495 if (CPU_ISSET(core
, cpu_set
)) break;
4497 thread_affinity_policy_data_t policy
= { core
};
4499 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4501 if (data
.quiet
== 0)
4503 if (rc
!= KERN_SUCCESS
)
4505 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4513 void set_cpu_affinity (char *cpu_affinity
)
4516 DWORD_PTR aff_mask
= 0;
4524 char *devices
= strdup (cpu_affinity
);
4526 char *next
= strtok (devices
, ",");
4530 uint cpu_id
= atoi (next
);
4545 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4551 aff_mask
|= 1 << (cpu_id
- 1);
4553 CPU_SET ((cpu_id
- 1), &cpuset
);
4556 } while ((next
= strtok (NULL
, ",")) != NULL
);
4562 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4563 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4565 pthread_t thread
= pthread_self ();
4566 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4570 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4572 char *element
, *end
;
4574 end
= (char *) base
+ nmemb
* size
;
4576 for (element
= (char *) base
; element
< end
; element
+= size
)
4577 if (!compar (element
, key
))
4583 int sort_by_u32 (const void *v1
, const void *v2
)
4585 const u32
*s1
= (const u32
*) v1
;
4586 const u32
*s2
= (const u32
*) v2
;
4591 int sort_by_salt (const void *v1
, const void *v2
)
4593 const salt_t
*s1
= (const salt_t
*) v1
;
4594 const salt_t
*s2
= (const salt_t
*) v2
;
4596 const int res1
= s1
->salt_len
- s2
->salt_len
;
4598 if (res1
!= 0) return (res1
);
4600 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4602 if (res2
!= 0) return (res2
);
4610 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4611 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4618 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4619 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4625 int sort_by_salt_buf (const void *v1
, const void *v2
)
4627 const pot_t
*p1
= (const pot_t
*) v1
;
4628 const pot_t
*p2
= (const pot_t
*) v2
;
4630 const hash_t
*h1
= &p1
->hash
;
4631 const hash_t
*h2
= &p2
->hash
;
4633 const salt_t
*s1
= h1
->salt
;
4634 const salt_t
*s2
= h2
->salt
;
4640 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4641 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4647 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4649 const hash_t
*h1
= (const hash_t
*) v1
;
4650 const hash_t
*h2
= (const hash_t
*) v2
;
4652 const salt_t
*s1
= h1
->salt
;
4653 const salt_t
*s2
= h2
->salt
;
4655 // testphase: this should work
4660 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4661 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4664 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4665 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4666 if (s1->salt_len > s2->salt_len) return ( 1);
4667 if (s1->salt_len < s2->salt_len) return (-1);
4669 uint n = s1->salt_len;
4673 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4674 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4681 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4683 const hash_t
*h1
= (const hash_t
*) v1
;
4684 const hash_t
*h2
= (const hash_t
*) v2
;
4686 const salt_t
*s1
= h1
->salt
;
4687 const salt_t
*s2
= h2
->salt
;
4689 // 16 - 2 (since last 2 uints contain the digest)
4694 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4695 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4701 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4703 const hash_t
*h1
= (const hash_t
*) v1
;
4704 const hash_t
*h2
= (const hash_t
*) v2
;
4706 const void *d1
= h1
->digest
;
4707 const void *d2
= h2
->digest
;
4709 return data
.sort_by_digest (d1
, d2
);
4712 int sort_by_hash (const void *v1
, const void *v2
)
4714 const hash_t
*h1
= (const hash_t
*) v1
;
4715 const hash_t
*h2
= (const hash_t
*) v2
;
4719 const salt_t
*s1
= h1
->salt
;
4720 const salt_t
*s2
= h2
->salt
;
4722 int res
= sort_by_salt (s1
, s2
);
4724 if (res
!= 0) return (res
);
4727 const void *d1
= h1
->digest
;
4728 const void *d2
= h2
->digest
;
4730 return data
.sort_by_digest (d1
, d2
);
4733 int sort_by_pot (const void *v1
, const void *v2
)
4735 const pot_t
*p1
= (const pot_t
*) v1
;
4736 const pot_t
*p2
= (const pot_t
*) v2
;
4738 const hash_t
*h1
= &p1
->hash
;
4739 const hash_t
*h2
= &p2
->hash
;
4741 return sort_by_hash (h1
, h2
);
4744 int sort_by_mtime (const void *p1
, const void *p2
)
4746 const char **f1
= (const char **) p1
;
4747 const char **f2
= (const char **) p2
;
4749 struct stat s1
; stat (*f1
, &s1
);
4750 struct stat s2
; stat (*f2
, &s2
);
4752 return s2
.st_mtime
- s1
.st_mtime
;
4755 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4757 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4758 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4760 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4763 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4765 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4766 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4768 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4771 int sort_by_stringptr (const void *p1
, const void *p2
)
4773 const char **s1
= (const char **) p1
;
4774 const char **s2
= (const char **) p2
;
4776 return strcmp (*s1
, *s2
);
4779 int sort_by_dictstat (const void *s1
, const void *s2
)
4781 dictstat_t
*d1
= (dictstat_t
*) s1
;
4782 dictstat_t
*d2
= (dictstat_t
*) s2
;
4785 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4787 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4790 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4793 int sort_by_bitmap (const void *p1
, const void *p2
)
4795 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4796 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4798 return b1
->collisions
- b2
->collisions
;
4801 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4803 const u32
*d1
= (const u32
*) v1
;
4804 const u32
*d2
= (const u32
*) v2
;
4810 if (d1
[n
] > d2
[n
]) return ( 1);
4811 if (d1
[n
] < d2
[n
]) return (-1);
4817 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4819 const u32
*d1
= (const u32
*) v1
;
4820 const u32
*d2
= (const u32
*) v2
;
4826 if (d1
[n
] > d2
[n
]) return ( 1);
4827 if (d1
[n
] < d2
[n
]) return (-1);
4833 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4835 const u32
*d1
= (const u32
*) v1
;
4836 const u32
*d2
= (const u32
*) v2
;
4842 if (d1
[n
] > d2
[n
]) return ( 1);
4843 if (d1
[n
] < d2
[n
]) return (-1);
4849 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4851 const u32
*d1
= (const u32
*) v1
;
4852 const u32
*d2
= (const u32
*) v2
;
4858 if (d1
[n
] > d2
[n
]) return ( 1);
4859 if (d1
[n
] < d2
[n
]) return (-1);
4865 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4867 const u32
*d1
= (const u32
*) v1
;
4868 const u32
*d2
= (const u32
*) v2
;
4874 if (d1
[n
] > d2
[n
]) return ( 1);
4875 if (d1
[n
] < d2
[n
]) return (-1);
4881 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4883 const u32
*d1
= (const u32
*) v1
;
4884 const u32
*d2
= (const u32
*) v2
;
4890 if (d1
[n
] > d2
[n
]) return ( 1);
4891 if (d1
[n
] < d2
[n
]) return (-1);
4897 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4899 const u32
*d1
= (const u32
*) v1
;
4900 const u32
*d2
= (const u32
*) v2
;
4906 if (d1
[n
] > d2
[n
]) return ( 1);
4907 if (d1
[n
] < d2
[n
]) return (-1);
4913 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4915 const u32
*d1
= (const u32
*) v1
;
4916 const u32
*d2
= (const u32
*) v2
;
4922 if (d1
[n
] > d2
[n
]) return ( 1);
4923 if (d1
[n
] < d2
[n
]) return (-1);
4929 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4931 const u64
*d1
= (const u64
*) v1
;
4932 const u64
*d2
= (const u64
*) v2
;
4938 if (d1
[n
] > d2
[n
]) return ( 1);
4939 if (d1
[n
] < d2
[n
]) return (-1);
4945 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4947 const u64
*d1
= (const u64
*) v1
;
4948 const u64
*d2
= (const u64
*) v2
;
4954 if (d1
[n
] > d2
[n
]) return ( 1);
4955 if (d1
[n
] < d2
[n
]) return (-1);
4961 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4963 const u64
*d1
= (const u64
*) v1
;
4964 const u64
*d2
= (const u64
*) v2
;
4970 if (d1
[n
] > d2
[n
]) return ( 1);
4971 if (d1
[n
] < d2
[n
]) return (-1);
4977 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4979 const u32
*d1
= (const u32
*) v1
;
4980 const u32
*d2
= (const u32
*) v2
;
4982 const uint dgst_pos0
= data
.dgst_pos0
;
4983 const uint dgst_pos1
= data
.dgst_pos1
;
4984 const uint dgst_pos2
= data
.dgst_pos2
;
4985 const uint dgst_pos3
= data
.dgst_pos3
;
4987 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4988 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4989 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4990 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4991 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4992 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4993 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4994 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4999 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5001 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5002 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5004 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5006 if (res1
!= 0) return (res1
);
5011 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5013 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5014 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5016 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5018 if (res1
!= 0) return (res1
);
5020 const int res2
= t1
->attack_mode
5023 if (res2
!= 0) return (res2
);
5025 const int res3
= t1
->hash_type
5028 if (res3
!= 0) return (res3
);
5033 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
)
5035 uint outfile_autohex
= data
.outfile_autohex
;
5037 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5039 FILE *debug_fp
= NULL
;
5041 if (debug_file
!= NULL
)
5043 debug_fp
= fopen (debug_file
, "ab");
5045 lock_file (debug_fp
);
5052 if (debug_fp
== NULL
)
5054 log_info ("WARNING: Could not open debug-file for writing");
5058 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5060 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5062 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5065 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5067 if (debug_mode
== 4)
5069 fputc (':', debug_fp
);
5071 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5074 fputc ('\n', debug_fp
);
5076 if (debug_file
!= NULL
) fclose (debug_fp
);
5080 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5082 int needs_hexify
= 0;
5084 if (outfile_autohex
== 1)
5086 for (uint i
= 0; i
< plain_len
; i
++)
5088 if (plain_ptr
[i
] < 0x20)
5095 if (plain_ptr
[i
] > 0x7f)
5104 if (needs_hexify
== 1)
5106 fprintf (fp
, "$HEX[");
5108 for (uint i
= 0; i
< plain_len
; i
++)
5110 fprintf (fp
, "%02x", plain_ptr
[i
]);
5117 fwrite (plain_ptr
, plain_len
, 1, fp
);
5121 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
)
5123 uint outfile_format
= data
.outfile_format
;
5125 char separator
= data
.separator
;
5127 if (outfile_format
& OUTFILE_FMT_HASH
)
5129 fprintf (out_fp
, "%s", out_buf
);
5131 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5133 fputc (separator
, out_fp
);
5136 else if (data
.username
)
5138 if (username
!= NULL
)
5140 for (uint i
= 0; i
< user_len
; i
++)
5142 fprintf (out_fp
, "%c", username
[i
]);
5145 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5147 fputc (separator
, out_fp
);
5152 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5154 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5156 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5158 fputc (separator
, out_fp
);
5162 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5164 for (uint i
= 0; i
< plain_len
; i
++)
5166 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5169 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5171 fputc (separator
, out_fp
);
5175 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5178 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5183 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5185 fprintf (out_fp
, "%llu", crackpos
);
5190 fputc ('\n', out_fp
);
5193 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
)
5197 pot_key
.hash
.salt
= hashes_buf
->salt
;
5198 pot_key
.hash
.digest
= hashes_buf
->digest
;
5200 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5206 input_buf
[input_len
] = 0;
5209 unsigned char *username
= NULL
;
5214 user_t
*user
= hashes_buf
->hash_info
->user
;
5218 username
= (unsigned char *) (user
->user_name
);
5220 user_len
= user
->user_len
;
5224 // do output the line
5225 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5229 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5230 #define LM_MASKED_PLAIN "[notfound]"
5232 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
)
5238 pot_left_key
.hash
.salt
= hash_left
->salt
;
5239 pot_left_key
.hash
.digest
= hash_left
->digest
;
5241 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5245 uint weak_hash_found
= 0;
5247 pot_t pot_right_key
;
5249 pot_right_key
.hash
.salt
= hash_right
->salt
;
5250 pot_right_key
.hash
.digest
= hash_right
->digest
;
5252 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5254 if (pot_right_ptr
== NULL
)
5256 // special case, if "weak hash"
5258 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5260 weak_hash_found
= 1;
5262 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5264 // in theory this is not needed, but we are paranoia:
5266 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5267 pot_right_ptr
->plain_len
= 0;
5271 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5273 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
5278 // at least one half was found:
5282 input_buf
[input_len
] = 0;
5286 unsigned char *username
= NULL
;
5291 user_t
*user
= hash_left
->hash_info
->user
;
5295 username
= (unsigned char *) (user
->user_name
);
5297 user_len
= user
->user_len
;
5301 // mask the part which was not found
5303 uint left_part_masked
= 0;
5304 uint right_part_masked
= 0;
5306 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5308 if (pot_left_ptr
== NULL
)
5310 left_part_masked
= 1;
5312 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5314 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5316 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5317 pot_left_ptr
->plain_len
= mask_plain_len
;
5320 if (pot_right_ptr
== NULL
)
5322 right_part_masked
= 1;
5324 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5326 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5328 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5329 pot_right_ptr
->plain_len
= mask_plain_len
;
5332 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5336 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5338 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5340 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5342 // do output the line
5344 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5346 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5348 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5349 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5352 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
)
5356 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5358 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5360 if (pot_ptr
== NULL
)
5364 input_buf
[input_len
] = 0;
5366 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5370 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
)
5376 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5378 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5382 pot_t pot_right_key
;
5384 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5386 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5388 uint weak_hash_found
= 0;
5390 if (pot_right_ptr
== NULL
)
5392 // special case, if "weak hash"
5394 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5396 weak_hash_found
= 1;
5398 // we just need that pot_right_ptr is not a NULL pointer
5400 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5404 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5406 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5411 // ... at least one part was not cracked
5415 input_buf
[input_len
] = 0;
5417 // only show the hash part which is still not cracked
5419 uint user_len
= input_len
- 32;
5421 char *hash_output
= (char *) mymalloc (33);
5423 memcpy (hash_output
, input_buf
, input_len
);
5425 if (pot_left_ptr
!= NULL
)
5427 // only show right part (because left part was already found)
5429 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5431 hash_output
[user_len
+ 16] = 0;
5434 if (pot_right_ptr
!= NULL
)
5436 // only show left part (because right part was already found)
5438 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5440 hash_output
[user_len
+ 16] = 0;
5443 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5445 myfree (hash_output
);
5447 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5450 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5452 uint opencl_platforms_filter
= 0;
5454 if (opencl_platforms
)
5456 char *platforms
= strdup (opencl_platforms
);
5458 char *next
= strtok (platforms
, ",");
5462 int platform
= atoi (next
);
5464 if (platform
< 1 || platform
> 32)
5466 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5471 opencl_platforms_filter
|= 1 << (platform
- 1);
5473 } while ((next
= strtok (NULL
, ",")) != NULL
);
5479 opencl_platforms_filter
= -1;
5482 return opencl_platforms_filter
;
5485 u32
setup_devices_filter (char *opencl_devices
)
5487 u32 devices_filter
= 0;
5491 char *devices
= strdup (opencl_devices
);
5493 char *next
= strtok (devices
, ",");
5497 int device_id
= atoi (next
);
5499 if (device_id
< 1 || device_id
> 32)
5501 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5506 devices_filter
|= 1 << (device_id
- 1);
5508 } while ((next
= strtok (NULL
, ",")) != NULL
);
5514 devices_filter
= -1;
5517 return devices_filter
;
5520 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5522 cl_device_type device_types_filter
= 0;
5524 if (opencl_device_types
)
5526 char *device_types
= strdup (opencl_device_types
);
5528 char *next
= strtok (device_types
, ",");
5532 int device_type
= atoi (next
);
5534 if (device_type
< 1 || device_type
> 3)
5536 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5541 device_types_filter
|= 1 << device_type
;
5543 } while ((next
= strtok (NULL
, ",")) != NULL
);
5545 free (device_types
);
5549 // Do not use CPU by default, this often reduces GPU performance because
5550 // the CPU is too busy to handle GPU synchronization
5552 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5555 return device_types_filter
;
5558 u32
get_random_num (const u32 min
, const u32 max
)
5560 if (min
== max
) return (min
);
5562 return ((rand () % (max
- min
)) + min
);
5565 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5567 u32 quotient
= dividend
/ divisor
;
5569 if (dividend
% divisor
) quotient
++;
5574 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5576 u64 quotient
= dividend
/ divisor
;
5578 if (dividend
% divisor
) quotient
++;
5583 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5585 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5586 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5588 if (tm
->tm_year
- 70)
5590 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5591 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5593 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5595 else if (tm
->tm_yday
)
5597 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5598 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5600 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5602 else if (tm
->tm_hour
)
5604 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5605 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5607 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5609 else if (tm
->tm_min
)
5611 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5612 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5614 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5618 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5620 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5624 void format_speed_display (float val
, char *buf
, size_t len
)
5635 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5646 /* generate output */
5650 snprintf (buf
, len
- 1, "%.0f ", val
);
5654 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5658 void lowercase (u8
*buf
, int len
)
5660 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5663 void uppercase (u8
*buf
, int len
)
5665 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5668 int fgetl (FILE *fp
, char *line_buf
)
5674 const int c
= fgetc (fp
);
5676 if (c
== EOF
) break;
5678 line_buf
[line_len
] = (char) c
;
5682 if (line_len
== HCBUFSIZ
) line_len
--;
5684 if (c
== '\n') break;
5687 if (line_len
== 0) return 0;
5689 if (line_buf
[line_len
- 1] == '\n')
5693 line_buf
[line_len
] = 0;
5696 if (line_len
== 0) return 0;
5698 if (line_buf
[line_len
- 1] == '\r')
5702 line_buf
[line_len
] = 0;
5708 int in_superchop (char *buf
)
5710 int len
= strlen (buf
);
5714 if (buf
[len
- 1] == '\n')
5721 if (buf
[len
- 1] == '\r')
5736 char **scan_directory (const char *path
)
5738 char *tmp_path
= mystrdup (path
);
5740 size_t tmp_path_len
= strlen (tmp_path
);
5742 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5744 tmp_path
[tmp_path_len
- 1] = 0;
5746 tmp_path_len
= strlen (tmp_path
);
5749 char **files
= NULL
;
5755 if ((d
= opendir (tmp_path
)) != NULL
)
5761 memset (&e
, 0, sizeof (e
));
5762 struct dirent
*de
= NULL
;
5764 if (readdir_r (d
, &e
, &de
) != 0)
5766 log_error ("ERROR: readdir_r() failed");
5771 if (de
== NULL
) break;
5775 while ((de
= readdir (d
)) != NULL
)
5778 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5780 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5782 char *path_file
= (char *) mymalloc (path_size
+ 1);
5784 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5786 path_file
[path_size
] = 0;
5790 if ((d_test
= opendir (path_file
)) != NULL
)
5798 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5802 files
[num_files
- 1] = path_file
;
5808 else if (errno
== ENOTDIR
)
5810 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5814 files
[num_files
- 1] = mystrdup (path
);
5817 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5821 files
[num_files
- 1] = NULL
;
5828 int count_dictionaries (char **dictionary_files
)
5830 if (dictionary_files
== NULL
) return 0;
5834 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5842 char *stroptitype (const uint opti_type
)
5846 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5847 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5848 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5849 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5850 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5851 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5852 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5853 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5854 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5855 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5856 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5857 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5858 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5859 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5860 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5861 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5862 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5863 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5864 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5870 char *strparser (const uint parser_status
)
5872 switch (parser_status
)
5874 case PARSER_OK
: return ((char *) PA_000
); break;
5875 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5876 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5877 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5878 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5879 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5880 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5881 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5882 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5883 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5884 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5885 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5886 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5887 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5888 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5889 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5890 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5893 return ((char *) PA_255
);
5896 char *strhashtype (const uint hash_mode
)
5900 case 0: return ((char *) HT_00000
); break;
5901 case 10: return ((char *) HT_00010
); break;
5902 case 11: return ((char *) HT_00011
); break;
5903 case 12: return ((char *) HT_00012
); break;
5904 case 20: return ((char *) HT_00020
); break;
5905 case 21: return ((char *) HT_00021
); break;
5906 case 22: return ((char *) HT_00022
); break;
5907 case 23: return ((char *) HT_00023
); break;
5908 case 30: return ((char *) HT_00030
); break;
5909 case 40: return ((char *) HT_00040
); break;
5910 case 50: return ((char *) HT_00050
); break;
5911 case 60: return ((char *) HT_00060
); break;
5912 case 100: return ((char *) HT_00100
); break;
5913 case 101: return ((char *) HT_00101
); break;
5914 case 110: return ((char *) HT_00110
); break;
5915 case 111: return ((char *) HT_00111
); break;
5916 case 112: return ((char *) HT_00112
); break;
5917 case 120: return ((char *) HT_00120
); break;
5918 case 121: return ((char *) HT_00121
); break;
5919 case 122: return ((char *) HT_00122
); break;
5920 case 124: return ((char *) HT_00124
); break;
5921 case 125: return ((char *) HT_00125
); break;
5922 case 130: return ((char *) HT_00130
); break;
5923 case 131: return ((char *) HT_00131
); break;
5924 case 132: return ((char *) HT_00132
); break;
5925 case 133: return ((char *) HT_00133
); break;
5926 case 140: return ((char *) HT_00140
); break;
5927 case 141: return ((char *) HT_00141
); break;
5928 case 150: return ((char *) HT_00150
); break;
5929 case 160: return ((char *) HT_00160
); break;
5930 case 200: return ((char *) HT_00200
); break;
5931 case 300: return ((char *) HT_00300
); break;
5932 case 400: return ((char *) HT_00400
); break;
5933 case 500: return ((char *) HT_00500
); break;
5934 case 501: return ((char *) HT_00501
); break;
5935 case 900: return ((char *) HT_00900
); break;
5936 case 910: return ((char *) HT_00910
); break;
5937 case 1000: return ((char *) HT_01000
); break;
5938 case 1100: return ((char *) HT_01100
); break;
5939 case 1400: return ((char *) HT_01400
); break;
5940 case 1410: return ((char *) HT_01410
); break;
5941 case 1420: return ((char *) HT_01420
); break;
5942 case 1421: return ((char *) HT_01421
); break;
5943 case 1430: return ((char *) HT_01430
); break;
5944 case 1440: return ((char *) HT_01440
); break;
5945 case 1441: return ((char *) HT_01441
); break;
5946 case 1450: return ((char *) HT_01450
); break;
5947 case 1460: return ((char *) HT_01460
); break;
5948 case 1500: return ((char *) HT_01500
); break;
5949 case 1600: return ((char *) HT_01600
); break;
5950 case 1700: return ((char *) HT_01700
); break;
5951 case 1710: return ((char *) HT_01710
); break;
5952 case 1711: return ((char *) HT_01711
); break;
5953 case 1720: return ((char *) HT_01720
); break;
5954 case 1722: return ((char *) HT_01722
); break;
5955 case 1730: return ((char *) HT_01730
); break;
5956 case 1731: return ((char *) HT_01731
); break;
5957 case 1740: return ((char *) HT_01740
); break;
5958 case 1750: return ((char *) HT_01750
); break;
5959 case 1760: return ((char *) HT_01760
); break;
5960 case 1800: return ((char *) HT_01800
); break;
5961 case 2100: return ((char *) HT_02100
); break;
5962 case 2400: return ((char *) HT_02400
); break;
5963 case 2410: return ((char *) HT_02410
); break;
5964 case 2500: return ((char *) HT_02500
); break;
5965 case 2600: return ((char *) HT_02600
); break;
5966 case 2611: return ((char *) HT_02611
); break;
5967 case 2612: return ((char *) HT_02612
); break;
5968 case 2711: return ((char *) HT_02711
); break;
5969 case 2811: return ((char *) HT_02811
); break;
5970 case 3000: return ((char *) HT_03000
); break;
5971 case 3100: return ((char *) HT_03100
); break;
5972 case 3200: return ((char *) HT_03200
); break;
5973 case 3710: return ((char *) HT_03710
); break;
5974 case 3711: return ((char *) HT_03711
); break;
5975 case 3800: return ((char *) HT_03800
); break;
5976 case 4300: return ((char *) HT_04300
); break;
5977 case 4400: return ((char *) HT_04400
); break;
5978 case 4500: return ((char *) HT_04500
); break;
5979 case 4700: return ((char *) HT_04700
); break;
5980 case 4800: return ((char *) HT_04800
); break;
5981 case 4900: return ((char *) HT_04900
); break;
5982 case 5000: return ((char *) HT_05000
); break;
5983 case 5100: return ((char *) HT_05100
); break;
5984 case 5200: return ((char *) HT_05200
); break;
5985 case 5300: return ((char *) HT_05300
); break;
5986 case 5400: return ((char *) HT_05400
); break;
5987 case 5500: return ((char *) HT_05500
); break;
5988 case 5600: return ((char *) HT_05600
); break;
5989 case 5700: return ((char *) HT_05700
); break;
5990 case 5800: return ((char *) HT_05800
); break;
5991 case 6000: return ((char *) HT_06000
); break;
5992 case 6100: return ((char *) HT_06100
); break;
5993 case 6211: return ((char *) HT_06211
); break;
5994 case 6212: return ((char *) HT_06212
); break;
5995 case 6213: return ((char *) HT_06213
); break;
5996 case 6221: return ((char *) HT_06221
); break;
5997 case 6222: return ((char *) HT_06222
); break;
5998 case 6223: return ((char *) HT_06223
); break;
5999 case 6231: return ((char *) HT_06231
); break;
6000 case 6232: return ((char *) HT_06232
); break;
6001 case 6233: return ((char *) HT_06233
); break;
6002 case 6241: return ((char *) HT_06241
); break;
6003 case 6242: return ((char *) HT_06242
); break;
6004 case 6243: return ((char *) HT_06243
); break;
6005 case 6300: return ((char *) HT_06300
); break;
6006 case 6400: return ((char *) HT_06400
); break;
6007 case 6500: return ((char *) HT_06500
); break;
6008 case 6600: return ((char *) HT_06600
); break;
6009 case 6700: return ((char *) HT_06700
); break;
6010 case 6800: return ((char *) HT_06800
); break;
6011 case 6900: return ((char *) HT_06900
); break;
6012 case 7100: return ((char *) HT_07100
); break;
6013 case 7200: return ((char *) HT_07200
); break;
6014 case 7300: return ((char *) HT_07300
); break;
6015 case 7400: return ((char *) HT_07400
); break;
6016 case 7500: return ((char *) HT_07500
); break;
6017 case 7600: return ((char *) HT_07600
); break;
6018 case 7700: return ((char *) HT_07700
); break;
6019 case 7800: return ((char *) HT_07800
); break;
6020 case 7900: return ((char *) HT_07900
); break;
6021 case 8000: return ((char *) HT_08000
); break;
6022 case 8100: return ((char *) HT_08100
); break;
6023 case 8200: return ((char *) HT_08200
); break;
6024 case 8300: return ((char *) HT_08300
); break;
6025 case 8400: return ((char *) HT_08400
); break;
6026 case 8500: return ((char *) HT_08500
); break;
6027 case 8600: return ((char *) HT_08600
); break;
6028 case 8700: return ((char *) HT_08700
); break;
6029 case 8800: return ((char *) HT_08800
); break;
6030 case 8900: return ((char *) HT_08900
); break;
6031 case 9000: return ((char *) HT_09000
); break;
6032 case 9100: return ((char *) HT_09100
); break;
6033 case 9200: return ((char *) HT_09200
); break;
6034 case 9300: return ((char *) HT_09300
); break;
6035 case 9400: return ((char *) HT_09400
); break;
6036 case 9500: return ((char *) HT_09500
); break;
6037 case 9600: return ((char *) HT_09600
); break;
6038 case 9700: return ((char *) HT_09700
); break;
6039 case 9710: return ((char *) HT_09710
); break;
6040 case 9720: return ((char *) HT_09720
); break;
6041 case 9800: return ((char *) HT_09800
); break;
6042 case 9810: return ((char *) HT_09810
); break;
6043 case 9820: return ((char *) HT_09820
); break;
6044 case 9900: return ((char *) HT_09900
); break;
6045 case 10000: return ((char *) HT_10000
); break;
6046 case 10100: return ((char *) HT_10100
); break;
6047 case 10200: return ((char *) HT_10200
); break;
6048 case 10300: return ((char *) HT_10300
); break;
6049 case 10400: return ((char *) HT_10400
); break;
6050 case 10410: return ((char *) HT_10410
); break;
6051 case 10420: return ((char *) HT_10420
); break;
6052 case 10500: return ((char *) HT_10500
); break;
6053 case 10600: return ((char *) HT_10600
); break;
6054 case 10700: return ((char *) HT_10700
); break;
6055 case 10800: return ((char *) HT_10800
); break;
6056 case 10900: return ((char *) HT_10900
); break;
6057 case 11000: return ((char *) HT_11000
); break;
6058 case 11100: return ((char *) HT_11100
); break;
6059 case 11200: return ((char *) HT_11200
); break;
6060 case 11300: return ((char *) HT_11300
); break;
6061 case 11400: return ((char *) HT_11400
); break;
6062 case 11500: return ((char *) HT_11500
); break;
6063 case 11600: return ((char *) HT_11600
); break;
6064 case 11700: return ((char *) HT_11700
); break;
6065 case 11800: return ((char *) HT_11800
); break;
6066 case 11900: return ((char *) HT_11900
); break;
6067 case 12000: return ((char *) HT_12000
); break;
6068 case 12100: return ((char *) HT_12100
); break;
6069 case 12200: return ((char *) HT_12200
); break;
6070 case 12300: return ((char *) HT_12300
); break;
6071 case 12400: return ((char *) HT_12400
); break;
6072 case 12500: return ((char *) HT_12500
); break;
6073 case 12600: return ((char *) HT_12600
); break;
6074 case 12700: return ((char *) HT_12700
); break;
6075 case 12800: return ((char *) HT_12800
); break;
6076 case 12900: return ((char *) HT_12900
); break;
6077 case 13000: return ((char *) HT_13000
); break;
6078 case 13100: return ((char *) HT_13100
); break;
6079 case 13200: return ((char *) HT_13200
); break;
6080 case 13300: return ((char *) HT_13300
); break;
6081 case 13400: return ((char *) HT_13400
); break;
6082 case 13500: return ((char *) HT_13500
); break;
6083 case 13600: return ((char *) HT_13600
); break;
6084 case 13711: return ((char *) HT_13711
); break;
6085 case 13712: return ((char *) HT_13712
); break;
6086 case 13713: return ((char *) HT_13713
); break;
6087 case 13721: return ((char *) HT_13721
); break;
6088 case 13722: return ((char *) HT_13722
); break;
6089 case 13723: return ((char *) HT_13723
); break;
6090 case 13731: return ((char *) HT_13731
); break;
6091 case 13732: return ((char *) HT_13732
); break;
6092 case 13733: return ((char *) HT_13733
); break;
6093 case 13741: return ((char *) HT_13741
); break;
6094 case 13742: return ((char *) HT_13742
); break;
6095 case 13743: return ((char *) HT_13743
); break;
6096 case 13751: return ((char *) HT_13751
); break;
6097 case 13752: return ((char *) HT_13752
); break;
6098 case 13753: return ((char *) HT_13753
); break;
6099 case 13761: return ((char *) HT_13761
); break;
6100 case 13762: return ((char *) HT_13762
); break;
6101 case 13763: return ((char *) HT_13763
); break;
6102 case 13800: return ((char *) HT_13800
); break;
6105 return ((char *) "Unknown");
6108 char *strstatus (const uint devices_status
)
6110 switch (devices_status
)
6112 case STATUS_INIT
: return ((char *) ST_0000
); break;
6113 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6114 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6115 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6116 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6117 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6118 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6119 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6120 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6121 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6122 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6125 return ((char *) "Unknown");
6128 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6130 uint hash_type
= data
.hash_type
;
6131 uint hash_mode
= data
.hash_mode
;
6132 uint salt_type
= data
.salt_type
;
6133 uint opts_type
= data
.opts_type
;
6134 uint opti_type
= data
.opti_type
;
6135 uint dgst_size
= data
.dgst_size
;
6137 char *hashfile
= data
.hashfile
;
6141 uint digest_buf
[64] = { 0 };
6143 u64
*digest_buf64
= (u64
*) digest_buf
;
6145 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6147 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6149 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6155 case HASH_TYPE_DESCRYPT
:
6156 FP (digest_buf
[1], digest_buf
[0], tt
);
6159 case HASH_TYPE_DESRACF
:
6160 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6161 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6163 FP (digest_buf
[1], digest_buf
[0], tt
);
6167 FP (digest_buf
[1], digest_buf
[0], tt
);
6170 case HASH_TYPE_NETNTLM
:
6171 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6172 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6173 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6174 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6176 FP (digest_buf
[1], digest_buf
[0], tt
);
6177 FP (digest_buf
[3], digest_buf
[2], tt
);
6180 case HASH_TYPE_BSDICRYPT
:
6181 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6182 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6184 FP (digest_buf
[1], digest_buf
[0], tt
);
6189 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6194 digest_buf
[0] += MD4M_A
;
6195 digest_buf
[1] += MD4M_B
;
6196 digest_buf
[2] += MD4M_C
;
6197 digest_buf
[3] += MD4M_D
;
6201 digest_buf
[0] += MD5M_A
;
6202 digest_buf
[1] += MD5M_B
;
6203 digest_buf
[2] += MD5M_C
;
6204 digest_buf
[3] += MD5M_D
;
6207 case HASH_TYPE_SHA1
:
6208 digest_buf
[0] += SHA1M_A
;
6209 digest_buf
[1] += SHA1M_B
;
6210 digest_buf
[2] += SHA1M_C
;
6211 digest_buf
[3] += SHA1M_D
;
6212 digest_buf
[4] += SHA1M_E
;
6215 case HASH_TYPE_SHA256
:
6216 digest_buf
[0] += SHA256M_A
;
6217 digest_buf
[1] += SHA256M_B
;
6218 digest_buf
[2] += SHA256M_C
;
6219 digest_buf
[3] += SHA256M_D
;
6220 digest_buf
[4] += SHA256M_E
;
6221 digest_buf
[5] += SHA256M_F
;
6222 digest_buf
[6] += SHA256M_G
;
6223 digest_buf
[7] += SHA256M_H
;
6226 case HASH_TYPE_SHA384
:
6227 digest_buf64
[0] += SHA384M_A
;
6228 digest_buf64
[1] += SHA384M_B
;
6229 digest_buf64
[2] += SHA384M_C
;
6230 digest_buf64
[3] += SHA384M_D
;
6231 digest_buf64
[4] += SHA384M_E
;
6232 digest_buf64
[5] += SHA384M_F
;
6233 digest_buf64
[6] += 0;
6234 digest_buf64
[7] += 0;
6237 case HASH_TYPE_SHA512
:
6238 digest_buf64
[0] += SHA512M_A
;
6239 digest_buf64
[1] += SHA512M_B
;
6240 digest_buf64
[2] += SHA512M_C
;
6241 digest_buf64
[3] += SHA512M_D
;
6242 digest_buf64
[4] += SHA512M_E
;
6243 digest_buf64
[5] += SHA512M_F
;
6244 digest_buf64
[6] += SHA512M_G
;
6245 digest_buf64
[7] += SHA512M_H
;
6250 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6252 if (dgst_size
== DGST_SIZE_4_2
)
6254 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6256 else if (dgst_size
== DGST_SIZE_4_4
)
6258 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6260 else if (dgst_size
== DGST_SIZE_4_5
)
6262 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6264 else if (dgst_size
== DGST_SIZE_4_6
)
6266 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6268 else if (dgst_size
== DGST_SIZE_4_8
)
6270 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6272 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6274 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6276 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6278 else if (hash_type
== HASH_TYPE_SHA384
)
6280 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6282 else if (hash_type
== HASH_TYPE_SHA512
)
6284 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6286 else if (hash_type
== HASH_TYPE_GOST
)
6288 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6291 else if (dgst_size
== DGST_SIZE_4_64
)
6293 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6295 else if (dgst_size
== DGST_SIZE_8_25
)
6297 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6301 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6302 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6303 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6309 memset (&salt
, 0, sizeof (salt_t
));
6311 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6313 char *ptr
= (char *) salt
.salt_buf
;
6315 uint len
= salt
.salt_len
;
6317 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6323 case HASH_TYPE_NETNTLM
:
6325 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6326 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6328 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6334 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6336 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6344 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6346 uint max
= salt
.salt_len
/ 4;
6350 for (uint i
= 0; i
< max
; i
++)
6352 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6356 if (opts_type
& OPTS_TYPE_ST_HEX
)
6358 char tmp
[64] = { 0 };
6360 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6362 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6367 memcpy (ptr
, tmp
, len
);
6370 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6372 memset (ptr
+ len
, 0, memset_size
);
6374 salt
.salt_len
= len
;
6378 // some modes require special encoding
6381 uint out_buf_plain
[256] = { 0 };
6382 uint out_buf_salt
[256] = { 0 };
6384 char tmp_buf
[1024] = { 0 };
6386 char *ptr_plain
= (char *) out_buf_plain
;
6387 char *ptr_salt
= (char *) out_buf_salt
;
6389 if (hash_mode
== 22)
6391 char username
[30] = { 0 };
6393 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6395 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6397 u16
*ptr
= (u16
*) digest_buf
;
6399 tmp_buf
[ 0] = sig
[0];
6400 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6401 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6402 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6403 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6404 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6405 tmp_buf
[ 6] = sig
[1];
6406 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6407 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6408 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6409 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6410 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6411 tmp_buf
[12] = sig
[2];
6412 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6413 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6414 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6415 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6416 tmp_buf
[17] = sig
[3];
6417 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6418 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6419 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6420 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6421 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6422 tmp_buf
[23] = sig
[4];
6423 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6424 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6425 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6426 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6427 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6428 tmp_buf
[29] = sig
[5];
6430 snprintf (out_buf
, len
-1, "%s:%s",
6434 else if (hash_mode
== 23)
6436 // do not show the skyper part in output
6438 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6440 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6442 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6449 else if (hash_mode
== 101)
6451 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6453 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6454 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6455 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6456 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6457 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6459 memcpy (tmp_buf
, digest_buf
, 20);
6461 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6463 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6465 else if (hash_mode
== 111)
6467 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6469 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6470 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6471 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6472 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6473 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6475 memcpy (tmp_buf
, digest_buf
, 20);
6476 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6478 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6480 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6482 else if ((hash_mode
== 122) || (hash_mode
== 125))
6484 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6485 (char *) salt
.salt_buf
,
6492 else if (hash_mode
== 124)
6494 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6495 (char *) salt
.salt_buf
,
6502 else if (hash_mode
== 131)
6504 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6505 (char *) salt
.salt_buf
,
6513 else if (hash_mode
== 132)
6515 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6516 (char *) salt
.salt_buf
,
6523 else if (hash_mode
== 133)
6525 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6527 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6528 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6529 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6530 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6531 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6533 memcpy (tmp_buf
, digest_buf
, 20);
6535 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6537 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6539 else if (hash_mode
== 141)
6541 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6543 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6545 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6547 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6549 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6550 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6551 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6552 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6553 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6555 memcpy (tmp_buf
, digest_buf
, 20);
6557 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6561 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6563 else if (hash_mode
== 400)
6565 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6567 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6568 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6569 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6570 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6572 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6574 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6576 else if (hash_mode
== 500)
6578 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6580 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6581 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6582 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6583 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6585 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6587 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6589 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6593 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6596 else if (hash_mode
== 501)
6598 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6600 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6601 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6603 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6605 else if (hash_mode
== 1421)
6607 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6609 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6625 else if (hash_mode
== 1441)
6627 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6629 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6631 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6633 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6635 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6636 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6637 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6638 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6639 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6640 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6641 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6642 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6644 memcpy (tmp_buf
, digest_buf
, 32);
6646 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6650 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6652 else if (hash_mode
== 1500)
6654 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6655 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6656 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6657 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6658 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6660 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6662 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6664 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6665 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6667 memcpy (tmp_buf
, digest_buf
, 8);
6669 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6671 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6675 else if (hash_mode
== 1600)
6677 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6679 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6680 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6681 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6682 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6684 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6686 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6688 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6692 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6695 else if (hash_mode
== 1711)
6697 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6699 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6700 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6701 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6702 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6703 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6704 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6705 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6706 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6708 memcpy (tmp_buf
, digest_buf
, 64);
6709 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6711 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6713 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6715 else if (hash_mode
== 1722)
6717 uint
*ptr
= digest_buf
;
6719 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6720 (unsigned char *) salt
.salt_buf
,
6730 else if (hash_mode
== 1731)
6732 uint
*ptr
= digest_buf
;
6734 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6735 (unsigned char *) salt
.salt_buf
,
6745 else if (hash_mode
== 1800)
6749 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6750 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6751 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6752 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6753 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6754 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6755 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6756 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6758 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6760 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6762 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6766 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6769 else if (hash_mode
== 2100)
6773 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6775 salt
.salt_iter
+ 1);
6777 uint signature_len
= strlen (out_buf
);
6779 pos
+= signature_len
;
6780 len
-= signature_len
;
6782 char *salt_ptr
= (char *) salt
.salt_buf
;
6784 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6786 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6787 byte_swap_32 (digest_buf
[0]),
6788 byte_swap_32 (digest_buf
[1]),
6789 byte_swap_32 (digest_buf
[2]),
6790 byte_swap_32 (digest_buf
[3]));
6792 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6794 memcpy (tmp_buf
, digest_buf
, 16);
6796 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6798 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6799 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6800 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6801 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6803 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6804 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6805 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6806 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6808 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6809 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6810 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6811 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6813 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6814 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6815 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6816 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6818 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6819 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6820 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6821 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6825 else if (hash_mode
== 2500)
6827 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6829 wpa_t
*wpa
= &wpas
[salt_pos
];
6831 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6832 (char *) salt
.salt_buf
,
6846 else if (hash_mode
== 4400)
6848 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6849 byte_swap_32 (digest_buf
[0]),
6850 byte_swap_32 (digest_buf
[1]),
6851 byte_swap_32 (digest_buf
[2]),
6852 byte_swap_32 (digest_buf
[3]));
6854 else if (hash_mode
== 4700)
6856 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6857 byte_swap_32 (digest_buf
[0]),
6858 byte_swap_32 (digest_buf
[1]),
6859 byte_swap_32 (digest_buf
[2]),
6860 byte_swap_32 (digest_buf
[3]),
6861 byte_swap_32 (digest_buf
[4]));
6863 else if (hash_mode
== 4800)
6865 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6867 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6872 byte_swap_32 (salt
.salt_buf
[0]),
6873 byte_swap_32 (salt
.salt_buf
[1]),
6874 byte_swap_32 (salt
.salt_buf
[2]),
6875 byte_swap_32 (salt
.salt_buf
[3]),
6878 else if (hash_mode
== 4900)
6880 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6881 byte_swap_32 (digest_buf
[0]),
6882 byte_swap_32 (digest_buf
[1]),
6883 byte_swap_32 (digest_buf
[2]),
6884 byte_swap_32 (digest_buf
[3]),
6885 byte_swap_32 (digest_buf
[4]));
6887 else if (hash_mode
== 5100)
6889 snprintf (out_buf
, len
-1, "%08x%08x",
6893 else if (hash_mode
== 5200)
6895 snprintf (out_buf
, len
-1, "%s", hashfile
);
6897 else if (hash_mode
== 5300)
6899 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6901 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6903 int buf_len
= len
-1;
6907 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6909 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6911 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6913 snprintf (out_buf
, buf_len
, ":");
6919 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6927 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6929 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6931 if ((i
== 0) || (i
== 5))
6933 snprintf (out_buf
, buf_len
, ":");
6939 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6947 for (uint i
= 0; i
< 4; i
++)
6951 snprintf (out_buf
, buf_len
, ":");
6957 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6963 else if (hash_mode
== 5400)
6965 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6967 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6969 int buf_len
= len
-1;
6973 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6975 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6977 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6979 snprintf (out_buf
, buf_len
, ":");
6985 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6993 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6995 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6997 if ((i
== 0) || (i
== 5))
6999 snprintf (out_buf
, buf_len
, ":");
7005 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7013 for (uint i
= 0; i
< 5; i
++)
7017 snprintf (out_buf
, buf_len
, ":");
7023 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7029 else if (hash_mode
== 5500)
7031 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7033 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7035 char user_buf
[64] = { 0 };
7036 char domain_buf
[64] = { 0 };
7037 char srvchall_buf
[1024] = { 0 };
7038 char clichall_buf
[1024] = { 0 };
7040 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7042 char *ptr
= (char *) netntlm
->userdomain_buf
;
7044 user_buf
[i
] = ptr
[j
];
7047 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7049 char *ptr
= (char *) netntlm
->userdomain_buf
;
7051 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7054 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7056 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7058 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7061 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7063 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7065 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7068 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7076 byte_swap_32 (salt
.salt_buf_pc
[0]),
7077 byte_swap_32 (salt
.salt_buf_pc
[1]),
7080 else if (hash_mode
== 5600)
7082 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7084 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7086 char user_buf
[64] = { 0 };
7087 char domain_buf
[64] = { 0 };
7088 char srvchall_buf
[1024] = { 0 };
7089 char clichall_buf
[1024] = { 0 };
7091 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7093 char *ptr
= (char *) netntlm
->userdomain_buf
;
7095 user_buf
[i
] = ptr
[j
];
7098 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7100 char *ptr
= (char *) netntlm
->userdomain_buf
;
7102 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7105 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7107 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7109 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7112 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7114 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7116 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7119 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7129 else if (hash_mode
== 5700)
7131 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7133 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7134 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7135 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7136 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7137 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7138 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7139 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7140 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7142 memcpy (tmp_buf
, digest_buf
, 32);
7144 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7148 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7150 else if (hash_mode
== 5800)
7152 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7153 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7154 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7155 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7156 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7158 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7165 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7167 snprintf (out_buf
, len
-1, "%s", hashfile
);
7169 else if (hash_mode
== 6300)
7171 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7173 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7174 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7175 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7176 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7178 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7180 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7182 else if (hash_mode
== 6400)
7184 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7186 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7188 else if (hash_mode
== 6500)
7190 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7192 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7194 else if (hash_mode
== 6600)
7196 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7198 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7200 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7201 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7203 uint buf_len
= len
- 1;
7205 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7208 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7210 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7215 else if (hash_mode
== 6700)
7217 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7219 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7221 else if (hash_mode
== 6800)
7223 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7225 else if (hash_mode
== 7100)
7227 uint
*ptr
= digest_buf
;
7229 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7231 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7233 uint esalt
[8] = { 0 };
7235 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7236 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7237 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7238 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7239 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7240 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7241 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7242 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7244 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",
7245 SIGNATURE_SHA512OSX
,
7247 esalt
[ 0], esalt
[ 1],
7248 esalt
[ 2], esalt
[ 3],
7249 esalt
[ 4], esalt
[ 5],
7250 esalt
[ 6], esalt
[ 7],
7258 ptr
[15], ptr
[14]);
7260 else if (hash_mode
== 7200)
7262 uint
*ptr
= digest_buf
;
7264 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7266 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7270 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7272 len_used
= strlen (out_buf
);
7274 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7276 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7278 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7281 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",
7289 ptr
[15], ptr
[14]);
7291 else if (hash_mode
== 7300)
7293 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7295 rakp_t
*rakp
= &rakps
[salt_pos
];
7297 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7299 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7302 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7309 else if (hash_mode
== 7400)
7311 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7313 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7314 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7315 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7316 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7317 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7318 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7319 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7320 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7322 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7324 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7326 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7330 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7333 else if (hash_mode
== 7500)
7335 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7337 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7339 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7340 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7342 char data
[128] = { 0 };
7344 char *ptr_data
= data
;
7346 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7348 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7351 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7353 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7358 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7360 (char *) krb5pa
->user
,
7361 (char *) krb5pa
->realm
,
7362 (char *) krb5pa
->salt
,
7365 else if (hash_mode
== 7700)
7367 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7368 (char *) salt
.salt_buf
,
7372 else if (hash_mode
== 7800)
7374 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7375 (char *) salt
.salt_buf
,
7382 else if (hash_mode
== 7900)
7384 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7388 char *tmp
= (char *) salt
.salt_buf_pc
;
7390 ptr_plain
[42] = tmp
[0];
7396 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7398 else if (hash_mode
== 8000)
7400 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7401 (unsigned char *) salt
.salt_buf
,
7411 else if (hash_mode
== 8100)
7413 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7414 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7416 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7417 (unsigned char *) salt
.salt_buf
,
7424 else if (hash_mode
== 8200)
7426 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7428 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7430 char data_buf
[4096] = { 0 };
7432 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7434 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7437 data_buf
[cloudkey
->data_len
* 2] = 0;
7439 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7440 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7441 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7442 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7443 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7444 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7445 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7446 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7448 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7449 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7450 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7451 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7453 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7469 else if (hash_mode
== 8300)
7471 char digest_buf_c
[34] = { 0 };
7473 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7474 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7475 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7476 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7477 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7479 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7481 digest_buf_c
[32] = 0;
7485 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7487 char domain_buf_c
[33] = { 0 };
7489 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7491 for (uint i
= 0; i
< salt_pc_len
; i
++)
7493 const char next
= domain_buf_c
[i
];
7495 domain_buf_c
[i
] = '.';
7500 domain_buf_c
[salt_pc_len
] = 0;
7504 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7506 else if (hash_mode
== 8500)
7508 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7510 else if (hash_mode
== 2612)
7512 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7514 (char *) salt
.salt_buf
,
7520 else if (hash_mode
== 3711)
7522 char *salt_ptr
= (char *) salt
.salt_buf
;
7524 salt_ptr
[salt
.salt_len
- 1] = 0;
7526 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7527 SIGNATURE_MEDIAWIKI_B
,
7534 else if (hash_mode
== 8800)
7536 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7538 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7540 char tmp
[3073] = { 0 };
7542 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7544 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7549 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7550 SIGNATURE_ANDROIDFDE
,
7551 byte_swap_32 (salt
.salt_buf
[0]),
7552 byte_swap_32 (salt
.salt_buf
[1]),
7553 byte_swap_32 (salt
.salt_buf
[2]),
7554 byte_swap_32 (salt
.salt_buf
[3]),
7555 byte_swap_32 (digest_buf
[0]),
7556 byte_swap_32 (digest_buf
[1]),
7557 byte_swap_32 (digest_buf
[2]),
7558 byte_swap_32 (digest_buf
[3]),
7561 else if (hash_mode
== 8900)
7563 uint N
= salt
.scrypt_N
;
7564 uint r
= salt
.scrypt_r
;
7565 uint p
= salt
.scrypt_p
;
7567 char base64_salt
[32] = { 0 };
7569 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7571 memset (tmp_buf
, 0, 46);
7573 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7574 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7575 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7576 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7577 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7578 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7579 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7580 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7581 digest_buf
[8] = 0; // needed for base64_encode ()
7583 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7585 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7593 else if (hash_mode
== 9000)
7595 snprintf (out_buf
, len
-1, "%s", hashfile
);
7597 else if (hash_mode
== 9200)
7601 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7603 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7605 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7609 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7610 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7611 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7612 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7613 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7614 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7615 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7616 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7617 digest_buf
[8] = 0; // needed for base64_encode ()
7619 char tmp_buf
[64] = { 0 };
7621 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7622 tmp_buf
[43] = 0; // cut it here
7626 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7628 else if (hash_mode
== 9300)
7630 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7631 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7632 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7633 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7634 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7635 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7636 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7637 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7638 digest_buf
[8] = 0; // needed for base64_encode ()
7640 char tmp_buf
[64] = { 0 };
7642 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7643 tmp_buf
[43] = 0; // cut it here
7645 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7647 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7649 else if (hash_mode
== 9400)
7651 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7653 office2007_t
*office2007
= &office2007s
[salt_pos
];
7655 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7656 SIGNATURE_OFFICE2007
,
7659 office2007
->keySize
,
7665 office2007
->encryptedVerifier
[0],
7666 office2007
->encryptedVerifier
[1],
7667 office2007
->encryptedVerifier
[2],
7668 office2007
->encryptedVerifier
[3],
7669 office2007
->encryptedVerifierHash
[0],
7670 office2007
->encryptedVerifierHash
[1],
7671 office2007
->encryptedVerifierHash
[2],
7672 office2007
->encryptedVerifierHash
[3],
7673 office2007
->encryptedVerifierHash
[4]);
7675 else if (hash_mode
== 9500)
7677 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7679 office2010_t
*office2010
= &office2010s
[salt_pos
];
7681 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,
7687 office2010
->encryptedVerifier
[0],
7688 office2010
->encryptedVerifier
[1],
7689 office2010
->encryptedVerifier
[2],
7690 office2010
->encryptedVerifier
[3],
7691 office2010
->encryptedVerifierHash
[0],
7692 office2010
->encryptedVerifierHash
[1],
7693 office2010
->encryptedVerifierHash
[2],
7694 office2010
->encryptedVerifierHash
[3],
7695 office2010
->encryptedVerifierHash
[4],
7696 office2010
->encryptedVerifierHash
[5],
7697 office2010
->encryptedVerifierHash
[6],
7698 office2010
->encryptedVerifierHash
[7]);
7700 else if (hash_mode
== 9600)
7702 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7704 office2013_t
*office2013
= &office2013s
[salt_pos
];
7706 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,
7712 office2013
->encryptedVerifier
[0],
7713 office2013
->encryptedVerifier
[1],
7714 office2013
->encryptedVerifier
[2],
7715 office2013
->encryptedVerifier
[3],
7716 office2013
->encryptedVerifierHash
[0],
7717 office2013
->encryptedVerifierHash
[1],
7718 office2013
->encryptedVerifierHash
[2],
7719 office2013
->encryptedVerifierHash
[3],
7720 office2013
->encryptedVerifierHash
[4],
7721 office2013
->encryptedVerifierHash
[5],
7722 office2013
->encryptedVerifierHash
[6],
7723 office2013
->encryptedVerifierHash
[7]);
7725 else if (hash_mode
== 9700)
7727 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7729 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7731 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7732 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7733 byte_swap_32 (salt
.salt_buf
[0]),
7734 byte_swap_32 (salt
.salt_buf
[1]),
7735 byte_swap_32 (salt
.salt_buf
[2]),
7736 byte_swap_32 (salt
.salt_buf
[3]),
7737 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7738 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7739 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7740 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7741 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7742 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7743 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7744 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7746 else if (hash_mode
== 9710)
7748 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7750 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7752 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7753 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7754 byte_swap_32 (salt
.salt_buf
[0]),
7755 byte_swap_32 (salt
.salt_buf
[1]),
7756 byte_swap_32 (salt
.salt_buf
[2]),
7757 byte_swap_32 (salt
.salt_buf
[3]),
7758 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7759 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7760 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7761 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7762 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7763 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7764 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7765 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7767 else if (hash_mode
== 9720)
7769 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7771 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7773 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7775 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7776 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7777 byte_swap_32 (salt
.salt_buf
[0]),
7778 byte_swap_32 (salt
.salt_buf
[1]),
7779 byte_swap_32 (salt
.salt_buf
[2]),
7780 byte_swap_32 (salt
.salt_buf
[3]),
7781 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7782 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7783 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7784 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7785 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7786 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7787 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7788 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7795 else if (hash_mode
== 9800)
7797 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7799 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7801 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7802 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7807 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7808 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7809 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7810 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7811 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7812 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7813 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7814 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7815 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7817 else if (hash_mode
== 9810)
7819 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7821 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7823 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7824 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7829 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7830 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7831 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7832 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7833 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7834 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7835 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7836 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7837 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7839 else if (hash_mode
== 9820)
7841 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7843 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7845 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7847 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7848 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7853 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7854 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7855 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7856 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7857 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7858 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7859 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7860 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7861 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7868 else if (hash_mode
== 10000)
7872 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7874 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7876 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7880 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7881 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7882 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7883 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7884 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7885 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7886 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7887 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7888 digest_buf
[8] = 0; // needed for base64_encode ()
7890 char tmp_buf
[64] = { 0 };
7892 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7896 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7898 else if (hash_mode
== 10100)
7900 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7905 byte_swap_32 (salt
.salt_buf
[0]),
7906 byte_swap_32 (salt
.salt_buf
[1]),
7907 byte_swap_32 (salt
.salt_buf
[2]),
7908 byte_swap_32 (salt
.salt_buf
[3]));
7910 else if (hash_mode
== 10200)
7912 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7914 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7918 char challenge
[100] = { 0 };
7920 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7924 char tmp_buf
[100] = { 0 };
7926 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7927 (char *) cram_md5
->user
,
7933 char response
[100] = { 0 };
7935 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7937 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7939 else if (hash_mode
== 10300)
7941 char tmp_buf
[100] = { 0 };
7943 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7944 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7946 uint tmp_len
= 20 + salt
.salt_len
;
7950 char base64_encoded
[100] = { 0 };
7952 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7954 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7956 else if (hash_mode
== 10400)
7958 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7960 pdf_t
*pdf
= &pdfs
[salt_pos
];
7962 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",
7970 byte_swap_32 (pdf
->id_buf
[0]),
7971 byte_swap_32 (pdf
->id_buf
[1]),
7972 byte_swap_32 (pdf
->id_buf
[2]),
7973 byte_swap_32 (pdf
->id_buf
[3]),
7975 byte_swap_32 (pdf
->u_buf
[0]),
7976 byte_swap_32 (pdf
->u_buf
[1]),
7977 byte_swap_32 (pdf
->u_buf
[2]),
7978 byte_swap_32 (pdf
->u_buf
[3]),
7979 byte_swap_32 (pdf
->u_buf
[4]),
7980 byte_swap_32 (pdf
->u_buf
[5]),
7981 byte_swap_32 (pdf
->u_buf
[6]),
7982 byte_swap_32 (pdf
->u_buf
[7]),
7984 byte_swap_32 (pdf
->o_buf
[0]),
7985 byte_swap_32 (pdf
->o_buf
[1]),
7986 byte_swap_32 (pdf
->o_buf
[2]),
7987 byte_swap_32 (pdf
->o_buf
[3]),
7988 byte_swap_32 (pdf
->o_buf
[4]),
7989 byte_swap_32 (pdf
->o_buf
[5]),
7990 byte_swap_32 (pdf
->o_buf
[6]),
7991 byte_swap_32 (pdf
->o_buf
[7])
7994 else if (hash_mode
== 10410)
7996 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7998 pdf_t
*pdf
= &pdfs
[salt_pos
];
8000 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",
8008 byte_swap_32 (pdf
->id_buf
[0]),
8009 byte_swap_32 (pdf
->id_buf
[1]),
8010 byte_swap_32 (pdf
->id_buf
[2]),
8011 byte_swap_32 (pdf
->id_buf
[3]),
8013 byte_swap_32 (pdf
->u_buf
[0]),
8014 byte_swap_32 (pdf
->u_buf
[1]),
8015 byte_swap_32 (pdf
->u_buf
[2]),
8016 byte_swap_32 (pdf
->u_buf
[3]),
8017 byte_swap_32 (pdf
->u_buf
[4]),
8018 byte_swap_32 (pdf
->u_buf
[5]),
8019 byte_swap_32 (pdf
->u_buf
[6]),
8020 byte_swap_32 (pdf
->u_buf
[7]),
8022 byte_swap_32 (pdf
->o_buf
[0]),
8023 byte_swap_32 (pdf
->o_buf
[1]),
8024 byte_swap_32 (pdf
->o_buf
[2]),
8025 byte_swap_32 (pdf
->o_buf
[3]),
8026 byte_swap_32 (pdf
->o_buf
[4]),
8027 byte_swap_32 (pdf
->o_buf
[5]),
8028 byte_swap_32 (pdf
->o_buf
[6]),
8029 byte_swap_32 (pdf
->o_buf
[7])
8032 else if (hash_mode
== 10420)
8034 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8036 pdf_t
*pdf
= &pdfs
[salt_pos
];
8038 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8040 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",
8048 byte_swap_32 (pdf
->id_buf
[0]),
8049 byte_swap_32 (pdf
->id_buf
[1]),
8050 byte_swap_32 (pdf
->id_buf
[2]),
8051 byte_swap_32 (pdf
->id_buf
[3]),
8053 byte_swap_32 (pdf
->u_buf
[0]),
8054 byte_swap_32 (pdf
->u_buf
[1]),
8055 byte_swap_32 (pdf
->u_buf
[2]),
8056 byte_swap_32 (pdf
->u_buf
[3]),
8057 byte_swap_32 (pdf
->u_buf
[4]),
8058 byte_swap_32 (pdf
->u_buf
[5]),
8059 byte_swap_32 (pdf
->u_buf
[6]),
8060 byte_swap_32 (pdf
->u_buf
[7]),
8062 byte_swap_32 (pdf
->o_buf
[0]),
8063 byte_swap_32 (pdf
->o_buf
[1]),
8064 byte_swap_32 (pdf
->o_buf
[2]),
8065 byte_swap_32 (pdf
->o_buf
[3]),
8066 byte_swap_32 (pdf
->o_buf
[4]),
8067 byte_swap_32 (pdf
->o_buf
[5]),
8068 byte_swap_32 (pdf
->o_buf
[6]),
8069 byte_swap_32 (pdf
->o_buf
[7]),
8077 else if (hash_mode
== 10500)
8079 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8081 pdf_t
*pdf
= &pdfs
[salt_pos
];
8083 if (pdf
->id_len
== 32)
8085 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",
8093 byte_swap_32 (pdf
->id_buf
[0]),
8094 byte_swap_32 (pdf
->id_buf
[1]),
8095 byte_swap_32 (pdf
->id_buf
[2]),
8096 byte_swap_32 (pdf
->id_buf
[3]),
8097 byte_swap_32 (pdf
->id_buf
[4]),
8098 byte_swap_32 (pdf
->id_buf
[5]),
8099 byte_swap_32 (pdf
->id_buf
[6]),
8100 byte_swap_32 (pdf
->id_buf
[7]),
8102 byte_swap_32 (pdf
->u_buf
[0]),
8103 byte_swap_32 (pdf
->u_buf
[1]),
8104 byte_swap_32 (pdf
->u_buf
[2]),
8105 byte_swap_32 (pdf
->u_buf
[3]),
8106 byte_swap_32 (pdf
->u_buf
[4]),
8107 byte_swap_32 (pdf
->u_buf
[5]),
8108 byte_swap_32 (pdf
->u_buf
[6]),
8109 byte_swap_32 (pdf
->u_buf
[7]),
8111 byte_swap_32 (pdf
->o_buf
[0]),
8112 byte_swap_32 (pdf
->o_buf
[1]),
8113 byte_swap_32 (pdf
->o_buf
[2]),
8114 byte_swap_32 (pdf
->o_buf
[3]),
8115 byte_swap_32 (pdf
->o_buf
[4]),
8116 byte_swap_32 (pdf
->o_buf
[5]),
8117 byte_swap_32 (pdf
->o_buf
[6]),
8118 byte_swap_32 (pdf
->o_buf
[7])
8123 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",
8131 byte_swap_32 (pdf
->id_buf
[0]),
8132 byte_swap_32 (pdf
->id_buf
[1]),
8133 byte_swap_32 (pdf
->id_buf
[2]),
8134 byte_swap_32 (pdf
->id_buf
[3]),
8136 byte_swap_32 (pdf
->u_buf
[0]),
8137 byte_swap_32 (pdf
->u_buf
[1]),
8138 byte_swap_32 (pdf
->u_buf
[2]),
8139 byte_swap_32 (pdf
->u_buf
[3]),
8140 byte_swap_32 (pdf
->u_buf
[4]),
8141 byte_swap_32 (pdf
->u_buf
[5]),
8142 byte_swap_32 (pdf
->u_buf
[6]),
8143 byte_swap_32 (pdf
->u_buf
[7]),
8145 byte_swap_32 (pdf
->o_buf
[0]),
8146 byte_swap_32 (pdf
->o_buf
[1]),
8147 byte_swap_32 (pdf
->o_buf
[2]),
8148 byte_swap_32 (pdf
->o_buf
[3]),
8149 byte_swap_32 (pdf
->o_buf
[4]),
8150 byte_swap_32 (pdf
->o_buf
[5]),
8151 byte_swap_32 (pdf
->o_buf
[6]),
8152 byte_swap_32 (pdf
->o_buf
[7])
8156 else if (hash_mode
== 10600)
8158 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8160 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8161 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8163 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8165 else if (hash_mode
== 10700)
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
== 10900)
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
== 11100)
8185 u32 salt_challenge
= salt
.salt_buf
[0];
8187 salt_challenge
= byte_swap_32 (salt_challenge
);
8189 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8191 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8192 SIGNATURE_POSTGRESQL_AUTH
,
8200 else if (hash_mode
== 11200)
8202 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8203 SIGNATURE_MYSQL_AUTH
,
8204 (unsigned char *) salt
.salt_buf
,
8211 else if (hash_mode
== 11300)
8213 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8215 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8217 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8218 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8219 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8221 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8222 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8223 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8225 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8227 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8229 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8232 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8234 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8236 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8239 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8241 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8243 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8246 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8247 SIGNATURE_BITCOIN_WALLET
,
8251 (unsigned char *) salt
.salt_buf
,
8259 free (cry_master_buf
);
8261 free (public_key_buf
);
8263 else if (hash_mode
== 11400)
8265 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8267 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8268 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8270 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8272 else if (hash_mode
== 11600)
8274 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8276 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8278 const uint data_len
= seven_zip
->data_len
;
8280 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8282 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8284 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8286 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8289 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8290 SIGNATURE_SEVEN_ZIP
,
8294 (char *) seven_zip
->salt_buf
,
8296 seven_zip
->iv_buf
[0],
8297 seven_zip
->iv_buf
[1],
8298 seven_zip
->iv_buf
[2],
8299 seven_zip
->iv_buf
[3],
8301 seven_zip
->data_len
,
8302 seven_zip
->unpack_size
,
8307 else if (hash_mode
== 11700)
8309 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8319 else if (hash_mode
== 11800)
8321 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8339 else if (hash_mode
== 11900)
8341 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8343 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8344 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8346 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8348 else if (hash_mode
== 12000)
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
== 12100)
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
== 12200)
8368 uint
*ptr_digest
= digest_buf
;
8369 uint
*ptr_salt
= salt
.salt_buf
;
8371 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8378 else if (hash_mode
== 12300)
8380 uint
*ptr_digest
= digest_buf
;
8381 uint
*ptr_salt
= salt
.salt_buf
;
8383 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",
8384 ptr_digest
[ 0], ptr_digest
[ 1],
8385 ptr_digest
[ 2], ptr_digest
[ 3],
8386 ptr_digest
[ 4], ptr_digest
[ 5],
8387 ptr_digest
[ 6], ptr_digest
[ 7],
8388 ptr_digest
[ 8], ptr_digest
[ 9],
8389 ptr_digest
[10], ptr_digest
[11],
8390 ptr_digest
[12], ptr_digest
[13],
8391 ptr_digest
[14], ptr_digest
[15],
8397 else if (hash_mode
== 12400)
8399 // encode iteration count
8401 char salt_iter
[5] = { 0 };
8403 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8404 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8405 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8406 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8411 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8412 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8413 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8414 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8419 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8421 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8422 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8424 memcpy (tmp_buf
, digest_buf
, 8);
8426 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8430 // fill the resulting buffer
8432 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8434 else if (hash_mode
== 12500)
8436 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8438 byte_swap_32 (salt
.salt_buf
[0]),
8439 byte_swap_32 (salt
.salt_buf
[1]),
8445 else if (hash_mode
== 12600)
8447 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8448 digest_buf
[0] + salt
.salt_buf_pc
[0],
8449 digest_buf
[1] + salt
.salt_buf_pc
[1],
8450 digest_buf
[2] + salt
.salt_buf_pc
[2],
8451 digest_buf
[3] + salt
.salt_buf_pc
[3],
8452 digest_buf
[4] + salt
.salt_buf_pc
[4],
8453 digest_buf
[5] + salt
.salt_buf_pc
[5],
8454 digest_buf
[6] + salt
.salt_buf_pc
[6],
8455 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8457 else if (hash_mode
== 12700)
8459 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8461 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8462 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8464 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8466 else if (hash_mode
== 12800)
8468 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8470 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",
8483 byte_swap_32 (digest_buf
[0]),
8484 byte_swap_32 (digest_buf
[1]),
8485 byte_swap_32 (digest_buf
[2]),
8486 byte_swap_32 (digest_buf
[3]),
8487 byte_swap_32 (digest_buf
[4]),
8488 byte_swap_32 (digest_buf
[5]),
8489 byte_swap_32 (digest_buf
[6]),
8490 byte_swap_32 (digest_buf
[7])
8493 else if (hash_mode
== 12900)
8495 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",
8504 byte_swap_32 (digest_buf
[0]),
8505 byte_swap_32 (digest_buf
[1]),
8506 byte_swap_32 (digest_buf
[2]),
8507 byte_swap_32 (digest_buf
[3]),
8508 byte_swap_32 (digest_buf
[4]),
8509 byte_swap_32 (digest_buf
[5]),
8510 byte_swap_32 (digest_buf
[6]),
8511 byte_swap_32 (digest_buf
[7]),
8518 else if (hash_mode
== 13000)
8520 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8522 rar5_t
*rar5
= &rar5s
[salt_pos
];
8524 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8534 byte_swap_32 (digest_buf
[0]),
8535 byte_swap_32 (digest_buf
[1])
8538 else if (hash_mode
== 13100)
8540 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8542 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8544 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8545 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8547 char data
[2560 * 4 * 2] = { 0 };
8549 char *ptr_data
= data
;
8551 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8552 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8557 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8558 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8560 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8562 (char *) krb5tgs
->account_info
,
8566 else if (hash_mode
== 13200)
8568 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8582 else if (hash_mode
== 13300)
8584 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8585 SIGNATURE_AXCRYPT_SHA1
,
8591 else if (hash_mode
== 13400)
8593 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8595 keepass_t
*keepass
= &keepasss
[salt_pos
];
8597 u32 version
= (u32
) keepass
->version
;
8598 u32 rounds
= salt
.salt_iter
;
8599 u32 algorithm
= (u32
) keepass
->algorithm
;
8600 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8602 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8603 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8604 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8605 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8606 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8608 /* specific to version 1 */
8612 /* specific to version 2 */
8613 u32 expected_bytes_len
;
8614 u32
*ptr_expected_bytes
;
8616 u32 final_random_seed_len
;
8617 u32 transf_random_seed_len
;
8619 u32 contents_hash_len
;
8621 transf_random_seed_len
= 8;
8623 contents_hash_len
= 8;
8624 final_random_seed_len
= 8;
8627 final_random_seed_len
= 4;
8629 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8635 char *ptr_data
= out_buf
;
8637 ptr_data
+= strlen(out_buf
);
8642 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8643 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8648 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8649 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8654 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8655 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8662 contents_len
= (u32
) keepass
->contents_len
;
8663 ptr_contents
= (u32
*) keepass
->contents
;
8665 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8666 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8678 char ptr_contents_len
[10] = { 0 };
8680 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8682 sprintf (ptr_data
, "%d", contents_len
);
8684 ptr_data
+= strlen(ptr_contents_len
);
8689 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8690 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8692 else if (version
== 2)
8694 expected_bytes_len
= 8;
8695 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8697 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8698 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8703 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8704 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8718 sprintf (ptr_data
, "%d", keyfile_len
);
8725 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8726 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8729 else if (hash_mode
== 13500)
8731 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8733 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8735 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8737 char pstoken_tmp
[1024 + 1] = { 0 };
8739 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8741 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8743 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8746 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8754 else if (hash_mode
== 13600)
8756 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8758 zip2_t
*zip2
= &zip2s
[salt_pos
];
8760 const u32 salt_len
= zip2
->salt_len
;
8762 char salt_tmp
[32 + 1] = { 0 };
8764 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8766 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8768 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8771 const u32 data_len
= zip2
->data_len
;
8773 char data_tmp
[8192 + 1] = { 0 };
8775 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8777 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8779 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8782 const u32 auth_len
= zip2
->auth_len
;
8784 char auth_tmp
[20 + 1] = { 0 };
8786 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8788 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8790 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8793 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8794 SIGNATURE_ZIP2_START
,
8800 zip2
->compress_length
,
8803 SIGNATURE_ZIP2_STOP
);
8805 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8807 snprintf (out_buf
, len
-1, "%s", hashfile
);
8809 else if (hash_mode
== 13800)
8811 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8813 win8phone_t
*esalt
= &esalts
[salt_pos
];
8815 char buf
[256 + 1] = { 0 };
8817 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8819 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8822 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8835 if (hash_type
== HASH_TYPE_MD4
)
8837 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8843 else if (hash_type
== HASH_TYPE_MD5
)
8845 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8851 else if (hash_type
== HASH_TYPE_SHA1
)
8853 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8860 else if (hash_type
== HASH_TYPE_SHA256
)
8862 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8872 else if (hash_type
== HASH_TYPE_SHA384
)
8874 uint
*ptr
= digest_buf
;
8876 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8884 else if (hash_type
== HASH_TYPE_SHA512
)
8886 uint
*ptr
= digest_buf
;
8888 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8898 else if (hash_type
== HASH_TYPE_LM
)
8900 snprintf (out_buf
, len
-1, "%08x%08x",
8904 else if (hash_type
== HASH_TYPE_ORACLEH
)
8906 snprintf (out_buf
, len
-1, "%08X%08X",
8910 else if (hash_type
== HASH_TYPE_BCRYPT
)
8912 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8913 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8915 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8917 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8919 else if (hash_type
== HASH_TYPE_KECCAK
)
8921 uint
*ptr
= digest_buf
;
8923 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",
8951 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8953 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8955 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8962 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8964 digest_buf
[ 0] = digest_buf
[ 0];
8965 digest_buf
[ 1] = digest_buf
[ 1];
8966 digest_buf
[ 2] = digest_buf
[ 2];
8967 digest_buf
[ 3] = digest_buf
[ 3];
8968 digest_buf
[ 4] = digest_buf
[ 4];
8969 digest_buf
[ 5] = digest_buf
[ 5];
8970 digest_buf
[ 6] = digest_buf
[ 6];
8971 digest_buf
[ 7] = digest_buf
[ 7];
8972 digest_buf
[ 8] = digest_buf
[ 8];
8973 digest_buf
[ 9] = digest_buf
[ 9];
8974 digest_buf
[10] = digest_buf
[10];
8975 digest_buf
[11] = digest_buf
[11];
8976 digest_buf
[12] = digest_buf
[12];
8977 digest_buf
[13] = digest_buf
[13];
8978 digest_buf
[14] = digest_buf
[14];
8979 digest_buf
[15] = digest_buf
[15];
8981 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8999 else if (hash_type
== HASH_TYPE_GOST
)
9001 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9011 else if (hash_type
== HASH_TYPE_MYSQL
)
9013 snprintf (out_buf
, len
-1, "%08x%08x",
9017 else if (hash_type
== HASH_TYPE_LOTUS5
)
9019 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9025 else if (hash_type
== HASH_TYPE_LOTUS6
)
9027 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9028 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9029 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9030 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9032 char buf
[16] = { 0 };
9034 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9035 memcpy (buf
+ 5, digest_buf
, 9);
9039 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9041 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9044 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9046 else if (hash_type
== HASH_TYPE_LOTUS8
)
9048 char buf
[52] = { 0 };
9052 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9058 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9062 buf
[26] = salt
.salt_buf_pc
[0];
9063 buf
[27] = salt
.salt_buf_pc
[1];
9067 memcpy (buf
+ 28, digest_buf
, 8);
9069 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9073 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9075 else if (hash_type
== HASH_TYPE_CRC32
)
9077 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9081 if (salt_type
== SALT_TYPE_INTERN
)
9083 size_t pos
= strlen (out_buf
);
9085 out_buf
[pos
] = data
.separator
;
9087 char *ptr
= (char *) salt
.salt_buf
;
9089 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9091 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9095 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9097 memset (hccap
, 0, sizeof (hccap_t
));
9099 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9101 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9103 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9104 wpa_t
*wpa
= &wpas
[salt_pos
];
9106 hccap
->keyver
= wpa
->keyver
;
9108 hccap
->eapol_size
= wpa
->eapol_size
;
9110 if (wpa
->keyver
!= 1)
9112 uint eapol_tmp
[64] = { 0 };
9114 for (uint i
= 0; i
< 64; i
++)
9116 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9119 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9123 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9126 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9127 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9128 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9129 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9131 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9133 uint dgst_size
= data
.dgst_size
;
9135 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9137 if (wpa
->keyver
!= 1)
9139 uint digest_tmp
[4] = { 0 };
9141 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9142 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9143 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9144 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9146 memcpy (hccap
->keymic
, digest_tmp
, 16);
9150 memcpy (hccap
->keymic
, digest_ptr
, 16);
9154 void SuspendThreads ()
9156 if (data
.devices_status
== STATUS_RUNNING
)
9158 hc_timer_set (&data
.timer_paused
);
9160 data
.devices_status
= STATUS_PAUSED
;
9162 log_info ("Paused");
9166 void ResumeThreads ()
9168 if (data
.devices_status
== STATUS_PAUSED
)
9172 hc_timer_get (data
.timer_paused
, ms_paused
);
9174 data
.ms_paused
+= ms_paused
;
9176 data
.devices_status
= STATUS_RUNNING
;
9178 log_info ("Resumed");
9184 if (data
.devices_status
!= STATUS_RUNNING
) return;
9186 data
.devices_status
= STATUS_BYPASS
;
9188 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9191 void stop_at_checkpoint ()
9193 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9195 if (data
.devices_status
!= STATUS_RUNNING
) return;
9198 // this feature only makes sense if --restore-disable was not specified
9200 if (data
.restore_disable
== 1)
9202 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9207 // check if monitoring of Restore Point updates should be enabled or disabled
9209 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9211 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9213 // save the current restore point value
9215 data
.checkpoint_cur_words
= get_lowest_words_done ();
9217 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9221 data
.devices_status
= STATUS_RUNNING
;
9223 // reset the global value for checkpoint checks
9225 data
.checkpoint_cur_words
= 0;
9227 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9233 //if (data.devices_status == STATUS_INIT) return;
9234 //if (data.devices_status == STATUS_STARTING) return;
9236 data
.devices_status
= STATUS_ABORTED
;
9241 //if (data.devices_status == STATUS_INIT) return;
9242 //if (data.devices_status == STATUS_STARTING) return;
9244 data
.devices_status
= STATUS_QUIT
;
9247 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9249 const size_t len
= strlen (s
);
9251 for (size_t in
= 0; in
< len
; in
++)
9257 s
[in
] = replace_char
;
9262 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9264 char s_escaped
[1024] = { 0 };
9266 size_t s_escaped_max
= sizeof (s_escaped
);
9268 const size_t len
= strlen (s
);
9270 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9276 s_escaped
[out
] = escape_char
;
9281 if (out
== s_escaped_max
- 2) break;
9286 strncpy (s
, s_escaped
, s_max
- 1);
9289 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9291 FILE *fp
= fopen (kernel_file
, "rb");
9297 memset (&st
, 0, sizeof (st
));
9299 stat (kernel_file
, &st
);
9301 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9303 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9305 if (num_read
!= (size_t) st
.st_size
)
9307 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9314 buf
[st
.st_size
] = 0;
9316 for (int i
= 0; i
< num_devices
; i
++)
9318 kernel_lengths
[i
] = (size_t) st
.st_size
;
9320 kernel_sources
[i
] = buf
;
9325 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9333 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9335 if (binary_size
> 0)
9337 FILE *fp
= fopen (dst
, "wb");
9340 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9351 restore_data_t
*init_restore (int argc
, char **argv
)
9353 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9355 if (data
.restore_disable
== 0)
9357 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9361 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9365 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9374 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9376 int pidbin_len
= -1;
9379 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9381 FILE *fd
= fopen (pidbin
, "rb");
9385 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9387 pidbin
[pidbin_len
] = 0;
9391 char *argv0_r
= strrchr (argv
[0], '/');
9393 char *pidbin_r
= strrchr (pidbin
, '/');
9395 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9397 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9399 if (strcmp (argv0_r
, pidbin_r
) == 0)
9401 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9408 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9410 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9412 int pidbin2_len
= -1;
9414 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9415 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9417 pidbin
[pidbin_len
] = 0;
9418 pidbin2
[pidbin2_len
] = 0;
9422 if (strcmp (pidbin
, pidbin2
) == 0)
9424 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9437 if (rd
->version_bin
< RESTORE_MIN
)
9439 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9446 memset (rd
, 0, sizeof (restore_data_t
));
9448 rd
->version_bin
= VERSION_BIN
;
9451 rd
->pid
= getpid ();
9453 rd
->pid
= GetCurrentProcessId ();
9456 if (getcwd (rd
->cwd
, 255) == NULL
)
9469 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9471 FILE *fp
= fopen (eff_restore_file
, "rb");
9475 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9480 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9482 log_error ("ERROR: Can't read %s", eff_restore_file
);
9487 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9489 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9491 for (uint i
= 0; i
< rd
->argc
; i
++)
9493 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9495 log_error ("ERROR: Can't read %s", eff_restore_file
);
9500 size_t len
= strlen (buf
);
9502 if (len
) buf
[len
- 1] = 0;
9504 rd
->argv
[i
] = mystrdup (buf
);
9511 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9513 if (chdir (rd
->cwd
))
9515 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9516 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9517 " https://github.com/philsmd/analyze_hc_restore\n"
9518 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9524 u64
get_lowest_words_done ()
9528 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9530 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9532 if (device_param
->skipped
) continue;
9534 const u64 words_done
= device_param
->words_done
;
9536 if (words_done
< words_cur
) words_cur
= words_done
;
9539 // It's possible that a device's workload isn't finished right after a restore-case.
9540 // In that case, this function would return 0 and overwrite the real restore point
9541 // There's also data.words_cur which is set to rd->words_cur but it changes while
9542 // the attack is running therefore we should stick to rd->words_cur.
9543 // Note that -s influences rd->words_cur we should keep a close look on that.
9545 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9550 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9552 u64 words_cur
= get_lowest_words_done ();
9554 rd
->words_cur
= words_cur
;
9556 FILE *fp
= fopen (new_restore_file
, "wb");
9560 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9565 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9567 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9572 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9574 for (uint i
= 0; i
< rd
->argc
; i
++)
9576 fprintf (fp
, "%s", rd
->argv
[i
]);
9582 fsync (fileno (fp
));
9587 void cycle_restore ()
9589 const char *eff_restore_file
= data
.eff_restore_file
;
9590 const char *new_restore_file
= data
.new_restore_file
;
9592 restore_data_t
*rd
= data
.rd
;
9594 write_restore (new_restore_file
, rd
);
9598 memset (&st
, 0, sizeof(st
));
9600 if (stat (eff_restore_file
, &st
) == 0)
9602 if (unlink (eff_restore_file
))
9604 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9608 if (rename (new_restore_file
, eff_restore_file
))
9610 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9614 void check_checkpoint ()
9616 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9618 u64 words_cur
= get_lowest_words_done ();
9620 if (words_cur
!= data
.checkpoint_cur_words
)
9630 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9634 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9636 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9638 myfree (alias
->device_name
);
9639 myfree (alias
->alias_name
);
9642 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9644 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9646 myfree (entry
->device_name
);
9649 myfree (tuning_db
->alias_buf
);
9650 myfree (tuning_db
->entry_buf
);
9655 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9657 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9659 int num_lines
= count_lines (fp
);
9661 // a bit over-allocated
9663 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9664 tuning_db
->alias_cnt
= 0;
9666 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9667 tuning_db
->entry_cnt
= 0;
9672 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9674 FILE *fp
= fopen (tuning_db_file
, "rb");
9678 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9683 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9689 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9693 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9695 if (line_buf
== NULL
) break;
9699 const int line_len
= in_superchop (line_buf
);
9701 if (line_len
== 0) continue;
9703 if (line_buf
[0] == '#') continue;
9707 char *token_ptr
[7] = { NULL
};
9711 char *next
= strtok (line_buf
, "\t ");
9713 token_ptr
[token_cnt
] = next
;
9717 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9719 token_ptr
[token_cnt
] = next
;
9726 char *device_name
= token_ptr
[0];
9727 char *alias_name
= token_ptr
[1];
9729 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9731 alias
->device_name
= mystrdup (device_name
);
9732 alias
->alias_name
= mystrdup (alias_name
);
9734 tuning_db
->alias_cnt
++;
9736 else if (token_cnt
== 6)
9738 if ((token_ptr
[1][0] != '0') &&
9739 (token_ptr
[1][0] != '1') &&
9740 (token_ptr
[1][0] != '3') &&
9741 (token_ptr
[1][0] != '*'))
9743 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9748 if ((token_ptr
[3][0] != '1') &&
9749 (token_ptr
[3][0] != '2') &&
9750 (token_ptr
[3][0] != '4') &&
9751 (token_ptr
[3][0] != '8') &&
9752 (token_ptr
[3][0] != 'N'))
9754 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9759 char *device_name
= token_ptr
[0];
9761 int attack_mode
= -1;
9763 int vector_width
= -1;
9764 int kernel_accel
= -1;
9765 int kernel_loops
= -1;
9767 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9768 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9769 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9771 if (token_ptr
[4][0] != 'A')
9773 kernel_accel
= atoi (token_ptr
[4]);
9775 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9777 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9787 if (token_ptr
[5][0] != 'A')
9789 kernel_loops
= atoi (token_ptr
[5]);
9791 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9793 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9803 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9805 entry
->device_name
= mystrdup (device_name
);
9806 entry
->attack_mode
= attack_mode
;
9807 entry
->hash_type
= hash_type
;
9808 entry
->vector_width
= vector_width
;
9809 entry
->kernel_accel
= kernel_accel
;
9810 entry
->kernel_loops
= kernel_loops
;
9812 tuning_db
->entry_cnt
++;
9816 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9826 // todo: print loaded 'cnt' message
9828 // sort the database
9830 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9831 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9836 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9838 static tuning_db_entry_t s
;
9840 // first we need to convert all spaces in the device_name to underscore
9842 char *device_name_nospace
= strdup (device_param
->device_name
);
9844 int device_name_length
= strlen (device_name_nospace
);
9848 for (i
= 0; i
< device_name_length
; i
++)
9850 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9853 // find out if there's an alias configured
9855 tuning_db_alias_t a
;
9857 a
.device_name
= device_name_nospace
;
9859 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
);
9861 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9863 // attack-mode 6 and 7 are attack-mode 1 basically
9865 if (attack_mode
== 6) attack_mode
= 1;
9866 if (attack_mode
== 7) attack_mode
= 1;
9868 // bsearch is not ideal but fast enough
9870 s
.device_name
= device_name_nospace
;
9871 s
.attack_mode
= attack_mode
;
9872 s
.hash_type
= hash_type
;
9874 tuning_db_entry_t
*entry
= NULL
;
9876 // this will produce all 2^3 combinations required
9878 for (i
= 0; i
< 8; i
++)
9880 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9881 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9882 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9884 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9886 if (entry
!= NULL
) break;
9888 // in non-wildcard mode do some additional checks:
9892 // in case we have an alias-name
9894 if (alias_name
!= NULL
)
9896 s
.device_name
= alias_name
;
9898 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9900 if (entry
!= NULL
) break;
9903 // or by device type
9905 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9907 s
.device_name
= "DEVICE_TYPE_CPU";
9909 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9911 s
.device_name
= "DEVICE_TYPE_GPU";
9913 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9915 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9918 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9920 if (entry
!= NULL
) break;
9924 // free converted device_name
9926 myfree (device_name_nospace
);
9935 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9937 u8 tmp
[256] = { 0 };
9939 if (salt_len
> sizeof (tmp
))
9944 memcpy (tmp
, in
, salt_len
);
9946 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9948 if ((salt_len
% 2) == 0)
9950 u32 new_salt_len
= salt_len
/ 2;
9952 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9957 tmp
[i
] = hex_convert (p1
) << 0;
9958 tmp
[i
] |= hex_convert (p0
) << 4;
9961 salt_len
= new_salt_len
;
9968 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9970 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9973 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9975 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9979 u32
*tmp_uint
= (u32
*) tmp
;
9981 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9982 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9983 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9984 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9985 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9986 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9987 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9988 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9989 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9990 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9992 salt_len
= salt_len
* 2;
10000 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10002 lowercase (tmp
, salt_len
);
10005 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10007 uppercase (tmp
, salt_len
);
10010 u32 len
= salt_len
;
10012 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10017 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10022 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10024 u32
*tmp_uint
= (uint
*) tmp
;
10028 if (len
% 4) max
++;
10030 for (u32 i
= 0; i
< max
; i
++)
10032 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10035 // Important: we may need to increase the length of memcpy since
10036 // we don't want to "loose" some swapped bytes (could happen if
10037 // they do not perfectly fit in the 4-byte blocks)
10038 // Memcpy does always copy the bytes in the BE order, but since
10039 // we swapped them, some important bytes could be in positions
10040 // we normally skip with the original len
10042 if (len
% 4) len
+= 4 - (len
% 4);
10045 memcpy (out
, tmp
, len
);
10050 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10052 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10054 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10056 u32
*digest
= (u32
*) hash_buf
->digest
;
10058 salt_t
*salt
= hash_buf
->salt
;
10060 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10062 char *iter_pos
= input_buf
+ 4;
10064 salt
->salt_iter
= 1 << atoi (iter_pos
);
10066 char *salt_pos
= strchr (iter_pos
, '$');
10068 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10072 uint salt_len
= 16;
10074 salt
->salt_len
= salt_len
;
10076 u8 tmp_buf
[100] = { 0 };
10078 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10080 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10082 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10084 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10085 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10086 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10087 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10089 char *hash_pos
= salt_pos
+ 22;
10091 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10093 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10095 memcpy (digest
, tmp_buf
, 24);
10097 digest
[0] = byte_swap_32 (digest
[0]);
10098 digest
[1] = byte_swap_32 (digest
[1]);
10099 digest
[2] = byte_swap_32 (digest
[2]);
10100 digest
[3] = byte_swap_32 (digest
[3]);
10101 digest
[4] = byte_swap_32 (digest
[4]);
10102 digest
[5] = byte_swap_32 (digest
[5]);
10104 digest
[5] &= ~0xff; // its just 23 not 24 !
10106 return (PARSER_OK
);
10109 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10111 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10113 u32
*digest
= (u32
*) hash_buf
->digest
;
10115 u8 tmp_buf
[100] = { 0 };
10117 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10119 memcpy (digest
, tmp_buf
, 32);
10121 digest
[0] = byte_swap_32 (digest
[0]);
10122 digest
[1] = byte_swap_32 (digest
[1]);
10123 digest
[2] = byte_swap_32 (digest
[2]);
10124 digest
[3] = byte_swap_32 (digest
[3]);
10125 digest
[4] = byte_swap_32 (digest
[4]);
10126 digest
[5] = byte_swap_32 (digest
[5]);
10127 digest
[6] = byte_swap_32 (digest
[6]);
10128 digest
[7] = byte_swap_32 (digest
[7]);
10130 digest
[0] -= SHA256M_A
;
10131 digest
[1] -= SHA256M_B
;
10132 digest
[2] -= SHA256M_C
;
10133 digest
[3] -= SHA256M_D
;
10134 digest
[4] -= SHA256M_E
;
10135 digest
[5] -= SHA256M_F
;
10136 digest
[6] -= SHA256M_G
;
10137 digest
[7] -= SHA256M_H
;
10139 return (PARSER_OK
);
10142 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10144 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10146 u32
*digest
= (u32
*) hash_buf
->digest
;
10148 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10149 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10151 digest
[0] = byte_swap_32 (digest
[0]);
10152 digest
[1] = byte_swap_32 (digest
[1]);
10156 IP (digest
[0], digest
[1], tt
);
10158 digest
[0] = digest
[0];
10159 digest
[1] = digest
[1];
10163 return (PARSER_OK
);
10166 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10168 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10170 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10172 u32
*digest
= (u32
*) hash_buf
->digest
;
10174 salt_t
*salt
= hash_buf
->salt
;
10176 char *hash_pos
= input_buf
+ 10;
10178 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10179 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10180 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10181 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10182 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10184 digest
[0] -= SHA1M_A
;
10185 digest
[1] -= SHA1M_B
;
10186 digest
[2] -= SHA1M_C
;
10187 digest
[3] -= SHA1M_D
;
10188 digest
[4] -= SHA1M_E
;
10190 uint salt_len
= 10;
10192 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10194 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10196 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10198 salt
->salt_len
= salt_len
;
10200 return (PARSER_OK
);
10203 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10205 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10207 u32
*digest
= (u32
*) hash_buf
->digest
;
10209 salt_t
*salt
= hash_buf
->salt
;
10211 char *hash_pos
= input_buf
+ 8;
10213 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10214 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10215 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10216 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10217 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10219 digest
[0] -= SHA1M_A
;
10220 digest
[1] -= SHA1M_B
;
10221 digest
[2] -= SHA1M_C
;
10222 digest
[3] -= SHA1M_D
;
10223 digest
[4] -= SHA1M_E
;
10227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10229 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10233 salt
->salt_len
= salt_len
;
10235 return (PARSER_OK
);
10238 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10240 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10242 u64
*digest
= (u64
*) hash_buf
->digest
;
10244 salt_t
*salt
= hash_buf
->salt
;
10246 char *hash_pos
= input_buf
+ 8;
10248 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10249 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10250 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10251 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10252 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10253 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10254 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10255 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10257 digest
[0] -= SHA512M_A
;
10258 digest
[1] -= SHA512M_B
;
10259 digest
[2] -= SHA512M_C
;
10260 digest
[3] -= SHA512M_D
;
10261 digest
[4] -= SHA512M_E
;
10262 digest
[5] -= SHA512M_F
;
10263 digest
[6] -= SHA512M_G
;
10264 digest
[7] -= SHA512M_H
;
10268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10270 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10274 salt
->salt_len
= salt_len
;
10276 return (PARSER_OK
);
10279 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10281 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10283 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10287 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10290 u32
*digest
= (u32
*) hash_buf
->digest
;
10292 salt_t
*salt
= hash_buf
->salt
;
10294 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10295 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10296 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10297 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10299 digest
[0] = byte_swap_32 (digest
[0]);
10300 digest
[1] = byte_swap_32 (digest
[1]);
10301 digest
[2] = byte_swap_32 (digest
[2]);
10302 digest
[3] = byte_swap_32 (digest
[3]);
10304 digest
[0] -= MD5M_A
;
10305 digest
[1] -= MD5M_B
;
10306 digest
[2] -= MD5M_C
;
10307 digest
[3] -= MD5M_D
;
10309 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10311 uint salt_len
= input_len
- 32 - 1;
10313 char *salt_buf
= input_buf
+ 32 + 1;
10315 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10317 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10319 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10321 salt
->salt_len
= salt_len
;
10323 return (PARSER_OK
);
10326 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10328 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10330 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10334 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10339 char clean_input_buf
[32] = { 0 };
10341 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10342 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10344 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10348 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10354 clean_input_buf
[k
] = input_buf
[i
];
10362 u32
*digest
= (u32
*) hash_buf
->digest
;
10364 salt_t
*salt
= hash_buf
->salt
;
10366 u32 a
, b
, c
, d
, e
, f
;
10368 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10369 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10370 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10371 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10372 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10373 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10375 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10376 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10378 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10379 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10380 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10381 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10382 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10383 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10385 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10386 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10388 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10389 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10390 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10391 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10392 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10393 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10395 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10396 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10398 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10399 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10400 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10401 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10402 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10403 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10405 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10406 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10408 digest
[0] = byte_swap_32 (digest
[0]);
10409 digest
[1] = byte_swap_32 (digest
[1]);
10410 digest
[2] = byte_swap_32 (digest
[2]);
10411 digest
[3] = byte_swap_32 (digest
[3]);
10413 digest
[0] -= MD5M_A
;
10414 digest
[1] -= MD5M_B
;
10415 digest
[2] -= MD5M_C
;
10416 digest
[3] -= MD5M_D
;
10418 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10420 uint salt_len
= input_len
- 30 - 1;
10422 char *salt_buf
= input_buf
+ 30 + 1;
10424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10426 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10428 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10429 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10431 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10433 salt
->salt_len
= salt_len
;
10435 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10437 salt
->salt_len
+= 22;
10439 return (PARSER_OK
);
10442 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10444 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10446 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10450 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10453 u32
*digest
= (u32
*) hash_buf
->digest
;
10455 salt_t
*salt
= hash_buf
->salt
;
10457 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10458 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10459 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10460 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10461 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10463 digest
[0] -= SHA1M_A
;
10464 digest
[1] -= SHA1M_B
;
10465 digest
[2] -= SHA1M_C
;
10466 digest
[3] -= SHA1M_D
;
10467 digest
[4] -= SHA1M_E
;
10469 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10471 uint salt_len
= input_len
- 40 - 1;
10473 char *salt_buf
= input_buf
+ 40 + 1;
10475 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10477 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10479 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10481 salt
->salt_len
= salt_len
;
10483 return (PARSER_OK
);
10486 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10488 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10490 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10494 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10497 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10499 char *iter_pos
= input_buf
+ 6;
10501 salt_t
*salt
= hash_buf
->salt
;
10503 uint iter
= atoi (iter_pos
);
10507 iter
= ROUNDS_DCC2
;
10510 salt
->salt_iter
= iter
- 1;
10512 char *salt_pos
= strchr (iter_pos
, '#');
10514 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10518 char *digest_pos
= strchr (salt_pos
, '#');
10520 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10524 uint salt_len
= digest_pos
- salt_pos
- 1;
10526 u32
*digest
= (u32
*) hash_buf
->digest
;
10528 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10529 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10530 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10531 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10533 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10535 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10537 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10539 salt
->salt_len
= salt_len
;
10541 return (PARSER_OK
);
10544 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10546 u32
*digest
= (u32
*) hash_buf
->digest
;
10548 salt_t
*salt
= hash_buf
->salt
;
10550 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10554 memcpy (&in
, input_buf
, input_len
);
10556 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10558 memcpy (digest
, in
.keymic
, 16);
10561 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10562 The phrase "Pairwise key expansion"
10563 Access Point Address (referred to as Authenticator Address AA)
10564 Supplicant Address (referred to as Supplicant Address SA)
10565 Access Point Nonce (referred to as Authenticator Anonce)
10566 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10569 uint salt_len
= strlen (in
.essid
);
10573 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10575 return (PARSER_SALT_LENGTH
);
10578 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10580 salt
->salt_len
= salt_len
;
10582 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10584 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10586 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10588 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10590 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10591 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10595 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10596 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10599 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10601 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10602 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10606 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10607 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10610 for (int i
= 0; i
< 25; i
++)
10612 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10615 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10616 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10617 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10618 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10620 wpa
->keyver
= in
.keyver
;
10622 if (wpa
->keyver
> 255)
10624 log_info ("ATTENTION!");
10625 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10626 log_info (" This could be due to a recent aircrack-ng bug.");
10627 log_info (" The key version was automatically reset to a reasonable value.");
10630 wpa
->keyver
&= 0xff;
10633 wpa
->eapol_size
= in
.eapol_size
;
10635 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10637 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10639 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10641 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10643 if (wpa
->keyver
== 1)
10649 digest
[0] = byte_swap_32 (digest
[0]);
10650 digest
[1] = byte_swap_32 (digest
[1]);
10651 digest
[2] = byte_swap_32 (digest
[2]);
10652 digest
[3] = byte_swap_32 (digest
[3]);
10654 for (int i
= 0; i
< 64; i
++)
10656 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10660 uint32_t *p0
= (uint32_t *) in
.essid
;
10664 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10665 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10667 salt
->salt_buf
[10] = c0
;
10668 salt
->salt_buf
[11] = c1
;
10670 return (PARSER_OK
);
10673 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10675 u32
*digest
= (u32
*) hash_buf
->digest
;
10677 salt_t
*salt
= hash_buf
->salt
;
10679 if (input_len
== 0)
10681 log_error ("Password Safe v2 container not specified");
10686 FILE *fp
= fopen (input_buf
, "rb");
10690 log_error ("%s: %s", input_buf
, strerror (errno
));
10697 memset (&buf
, 0, sizeof (psafe2_hdr
));
10699 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10703 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10705 salt
->salt_buf
[0] = buf
.random
[0];
10706 salt
->salt_buf
[1] = buf
.random
[1];
10708 salt
->salt_len
= 8;
10709 salt
->salt_iter
= 1000;
10711 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10712 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10713 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10714 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10715 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10717 return (PARSER_OK
);
10720 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10722 u32
*digest
= (u32
*) hash_buf
->digest
;
10724 salt_t
*salt
= hash_buf
->salt
;
10726 if (input_len
== 0)
10728 log_error (".psafe3 not specified");
10733 FILE *fp
= fopen (input_buf
, "rb");
10737 log_error ("%s: %s", input_buf
, strerror (errno
));
10744 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10748 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10750 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10752 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10754 salt
->salt_iter
= in
.iterations
+ 1;
10756 salt
->salt_buf
[0] = in
.salt_buf
[0];
10757 salt
->salt_buf
[1] = in
.salt_buf
[1];
10758 salt
->salt_buf
[2] = in
.salt_buf
[2];
10759 salt
->salt_buf
[3] = in
.salt_buf
[3];
10760 salt
->salt_buf
[4] = in
.salt_buf
[4];
10761 salt
->salt_buf
[5] = in
.salt_buf
[5];
10762 salt
->salt_buf
[6] = in
.salt_buf
[6];
10763 salt
->salt_buf
[7] = in
.salt_buf
[7];
10765 salt
->salt_len
= 32;
10767 digest
[0] = in
.hash_buf
[0];
10768 digest
[1] = in
.hash_buf
[1];
10769 digest
[2] = in
.hash_buf
[2];
10770 digest
[3] = in
.hash_buf
[3];
10771 digest
[4] = in
.hash_buf
[4];
10772 digest
[5] = in
.hash_buf
[5];
10773 digest
[6] = in
.hash_buf
[6];
10774 digest
[7] = in
.hash_buf
[7];
10776 digest
[0] = byte_swap_32 (digest
[0]);
10777 digest
[1] = byte_swap_32 (digest
[1]);
10778 digest
[2] = byte_swap_32 (digest
[2]);
10779 digest
[3] = byte_swap_32 (digest
[3]);
10780 digest
[4] = byte_swap_32 (digest
[4]);
10781 digest
[5] = byte_swap_32 (digest
[5]);
10782 digest
[6] = byte_swap_32 (digest
[6]);
10783 digest
[7] = byte_swap_32 (digest
[7]);
10785 return (PARSER_OK
);
10788 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10790 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10792 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10794 u32
*digest
= (u32
*) hash_buf
->digest
;
10796 salt_t
*salt
= hash_buf
->salt
;
10798 char *iter_pos
= input_buf
+ 3;
10800 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10802 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10804 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10806 salt
->salt_iter
= salt_iter
;
10808 char *salt_pos
= iter_pos
+ 1;
10812 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10814 salt
->salt_len
= salt_len
;
10816 char *hash_pos
= salt_pos
+ salt_len
;
10818 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10820 return (PARSER_OK
);
10823 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10825 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10827 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10829 u32
*digest
= (u32
*) hash_buf
->digest
;
10831 salt_t
*salt
= hash_buf
->salt
;
10833 char *salt_pos
= input_buf
+ 3;
10835 uint iterations_len
= 0;
10837 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10841 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10843 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10844 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10848 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10852 iterations_len
+= 8;
10856 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10859 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10861 char *hash_pos
= strchr (salt_pos
, '$');
10863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10865 uint salt_len
= hash_pos
- salt_pos
;
10867 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10869 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10871 salt
->salt_len
= salt_len
;
10875 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10877 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10879 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10881 return (PARSER_OK
);
10884 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10886 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10888 u32
*digest
= (u32
*) hash_buf
->digest
;
10890 salt_t
*salt
= hash_buf
->salt
;
10892 char *salt_pos
= input_buf
+ 6;
10894 uint iterations_len
= 0;
10896 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10900 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10902 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10903 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10907 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10911 iterations_len
+= 8;
10915 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10918 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10920 char *hash_pos
= strchr (salt_pos
, '$');
10922 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10924 uint salt_len
= hash_pos
- salt_pos
;
10926 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10928 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10930 salt
->salt_len
= salt_len
;
10934 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10936 return (PARSER_OK
);
10939 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10941 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10943 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10945 u32
*digest
= (u32
*) hash_buf
->digest
;
10947 salt_t
*salt
= hash_buf
->salt
;
10949 char *salt_pos
= input_buf
+ 14;
10951 char *hash_pos
= strchr (salt_pos
, '*');
10953 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10957 uint salt_len
= hash_pos
- salt_pos
- 1;
10959 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10961 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10963 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10965 salt
->salt_len
= salt_len
;
10967 u8 tmp_buf
[100] = { 0 };
10969 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10971 memcpy (digest
, tmp_buf
, 20);
10973 digest
[0] = byte_swap_32 (digest
[0]);
10974 digest
[1] = byte_swap_32 (digest
[1]);
10975 digest
[2] = byte_swap_32 (digest
[2]);
10976 digest
[3] = byte_swap_32 (digest
[3]);
10977 digest
[4] = byte_swap_32 (digest
[4]);
10979 digest
[0] -= SHA1M_A
;
10980 digest
[1] -= SHA1M_B
;
10981 digest
[2] -= SHA1M_C
;
10982 digest
[3] -= SHA1M_D
;
10983 digest
[4] -= SHA1M_E
;
10985 return (PARSER_OK
);
10988 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10990 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10992 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10994 if (c12
& 3) return (PARSER_HASH_VALUE
);
10996 u32
*digest
= (u32
*) hash_buf
->digest
;
10998 salt_t
*salt
= hash_buf
->salt
;
11000 // for ascii_digest
11001 salt
->salt_sign
[0] = input_buf
[0];
11002 salt
->salt_sign
[1] = input_buf
[1];
11004 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11005 | itoa64_to_int (input_buf
[1]) << 6;
11007 salt
->salt_len
= 2;
11009 u8 tmp_buf
[100] = { 0 };
11011 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11013 memcpy (digest
, tmp_buf
, 8);
11017 IP (digest
[0], digest
[1], tt
);
11022 return (PARSER_OK
);
11025 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11027 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11029 u32
*digest
= (u32
*) hash_buf
->digest
;
11031 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11032 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11033 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11034 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11036 digest
[0] = byte_swap_32 (digest
[0]);
11037 digest
[1] = byte_swap_32 (digest
[1]);
11038 digest
[2] = byte_swap_32 (digest
[2]);
11039 digest
[3] = byte_swap_32 (digest
[3]);
11041 digest
[0] -= MD4M_A
;
11042 digest
[1] -= MD4M_B
;
11043 digest
[2] -= MD4M_C
;
11044 digest
[3] -= MD4M_D
;
11046 return (PARSER_OK
);
11049 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11051 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11053 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11057 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11060 u32
*digest
= (u32
*) hash_buf
->digest
;
11062 salt_t
*salt
= hash_buf
->salt
;
11064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11069 digest
[0] = byte_swap_32 (digest
[0]);
11070 digest
[1] = byte_swap_32 (digest
[1]);
11071 digest
[2] = byte_swap_32 (digest
[2]);
11072 digest
[3] = byte_swap_32 (digest
[3]);
11074 digest
[0] -= MD4M_A
;
11075 digest
[1] -= MD4M_B
;
11076 digest
[2] -= MD4M_C
;
11077 digest
[3] -= MD4M_D
;
11079 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11081 uint salt_len
= input_len
- 32 - 1;
11083 char *salt_buf
= input_buf
+ 32 + 1;
11085 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11091 salt
->salt_len
= salt_len
;
11093 return (PARSER_OK
);
11096 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11098 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11100 u32
*digest
= (u32
*) hash_buf
->digest
;
11102 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11103 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11104 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11105 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11107 digest
[0] = byte_swap_32 (digest
[0]);
11108 digest
[1] = byte_swap_32 (digest
[1]);
11109 digest
[2] = byte_swap_32 (digest
[2]);
11110 digest
[3] = byte_swap_32 (digest
[3]);
11112 digest
[0] -= MD5M_A
;
11113 digest
[1] -= MD5M_B
;
11114 digest
[2] -= MD5M_C
;
11115 digest
[3] -= MD5M_D
;
11117 return (PARSER_OK
);
11120 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11122 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11124 u32
*digest
= (u32
*) hash_buf
->digest
;
11126 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11127 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11131 digest
[0] = byte_swap_32 (digest
[0]);
11132 digest
[1] = byte_swap_32 (digest
[1]);
11134 return (PARSER_OK
);
11137 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11139 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11141 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11145 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11148 u32
*digest
= (u32
*) hash_buf
->digest
;
11150 salt_t
*salt
= hash_buf
->salt
;
11152 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11153 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11154 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11155 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11157 digest
[0] = byte_swap_32 (digest
[0]);
11158 digest
[1] = byte_swap_32 (digest
[1]);
11159 digest
[2] = byte_swap_32 (digest
[2]);
11160 digest
[3] = byte_swap_32 (digest
[3]);
11162 digest
[0] -= MD5M_A
;
11163 digest
[1] -= MD5M_B
;
11164 digest
[2] -= MD5M_C
;
11165 digest
[3] -= MD5M_D
;
11167 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11169 uint salt_len
= input_len
- 32 - 1;
11171 char *salt_buf
= input_buf
+ 32 + 1;
11173 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11175 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11177 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11179 salt
->salt_len
= salt_len
;
11181 return (PARSER_OK
);
11184 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11186 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11188 u32
*digest
= (u32
*) hash_buf
->digest
;
11190 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11191 | itoa64_to_int (input_buf
[ 1]) << 6
11192 | itoa64_to_int (input_buf
[ 2]) << 12
11193 | itoa64_to_int (input_buf
[ 3]) << 18;
11194 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11195 | itoa64_to_int (input_buf
[ 5]) << 6
11196 | itoa64_to_int (input_buf
[ 6]) << 12
11197 | itoa64_to_int (input_buf
[ 7]) << 18;
11198 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11199 | itoa64_to_int (input_buf
[ 9]) << 6
11200 | itoa64_to_int (input_buf
[10]) << 12
11201 | itoa64_to_int (input_buf
[11]) << 18;
11202 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11203 | itoa64_to_int (input_buf
[13]) << 6
11204 | itoa64_to_int (input_buf
[14]) << 12
11205 | itoa64_to_int (input_buf
[15]) << 18;
11207 digest
[0] -= MD5M_A
;
11208 digest
[1] -= MD5M_B
;
11209 digest
[2] -= MD5M_C
;
11210 digest
[3] -= MD5M_D
;
11212 digest
[0] &= 0x00ffffff;
11213 digest
[1] &= 0x00ffffff;
11214 digest
[2] &= 0x00ffffff;
11215 digest
[3] &= 0x00ffffff;
11217 return (PARSER_OK
);
11220 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11222 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11224 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11228 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11231 u32
*digest
= (u32
*) hash_buf
->digest
;
11233 salt_t
*salt
= hash_buf
->salt
;
11235 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11236 | itoa64_to_int (input_buf
[ 1]) << 6
11237 | itoa64_to_int (input_buf
[ 2]) << 12
11238 | itoa64_to_int (input_buf
[ 3]) << 18;
11239 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11240 | itoa64_to_int (input_buf
[ 5]) << 6
11241 | itoa64_to_int (input_buf
[ 6]) << 12
11242 | itoa64_to_int (input_buf
[ 7]) << 18;
11243 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11244 | itoa64_to_int (input_buf
[ 9]) << 6
11245 | itoa64_to_int (input_buf
[10]) << 12
11246 | itoa64_to_int (input_buf
[11]) << 18;
11247 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11248 | itoa64_to_int (input_buf
[13]) << 6
11249 | itoa64_to_int (input_buf
[14]) << 12
11250 | itoa64_to_int (input_buf
[15]) << 18;
11252 digest
[0] -= MD5M_A
;
11253 digest
[1] -= MD5M_B
;
11254 digest
[2] -= MD5M_C
;
11255 digest
[3] -= MD5M_D
;
11257 digest
[0] &= 0x00ffffff;
11258 digest
[1] &= 0x00ffffff;
11259 digest
[2] &= 0x00ffffff;
11260 digest
[3] &= 0x00ffffff;
11262 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11264 uint salt_len
= input_len
- 16 - 1;
11266 char *salt_buf
= input_buf
+ 16 + 1;
11268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11274 salt
->salt_len
= salt_len
;
11276 return (PARSER_OK
);
11279 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11281 key
[0] = (nthash
[0] >> 0);
11282 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11283 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11284 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11285 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11286 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11287 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11288 key
[7] = (nthash
[6] << 1);
11300 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11302 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11304 u32
*digest
= (u32
*) hash_buf
->digest
;
11306 salt_t
*salt
= hash_buf
->salt
;
11308 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11314 char *user_pos
= input_buf
;
11316 char *unused_pos
= strchr (user_pos
, ':');
11318 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11320 uint user_len
= unused_pos
- user_pos
;
11322 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11326 char *domain_pos
= strchr (unused_pos
, ':');
11328 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11330 uint unused_len
= domain_pos
- unused_pos
;
11332 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11336 char *srvchall_pos
= strchr (domain_pos
, ':');
11338 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11340 uint domain_len
= srvchall_pos
- domain_pos
;
11342 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11346 char *hash_pos
= strchr (srvchall_pos
, ':');
11348 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11350 uint srvchall_len
= hash_pos
- srvchall_pos
;
11352 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11356 char *clichall_pos
= strchr (hash_pos
, ':');
11358 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11360 uint hash_len
= clichall_pos
- hash_pos
;
11362 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11366 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11368 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11371 * store some data for later use
11374 netntlm
->user_len
= user_len
* 2;
11375 netntlm
->domain_len
= domain_len
* 2;
11376 netntlm
->srvchall_len
= srvchall_len
/ 2;
11377 netntlm
->clichall_len
= clichall_len
/ 2;
11379 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11380 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11383 * handle username and domainname
11386 for (uint i
= 0; i
< user_len
; i
++)
11388 *userdomain_ptr
++ = user_pos
[i
];
11389 *userdomain_ptr
++ = 0;
11392 for (uint i
= 0; i
< domain_len
; i
++)
11394 *userdomain_ptr
++ = domain_pos
[i
];
11395 *userdomain_ptr
++ = 0;
11399 * handle server challenge encoding
11402 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11404 const char p0
= srvchall_pos
[i
+ 0];
11405 const char p1
= srvchall_pos
[i
+ 1];
11407 *chall_ptr
++ = hex_convert (p1
) << 0
11408 | hex_convert (p0
) << 4;
11412 * handle client challenge encoding
11415 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11417 const char p0
= clichall_pos
[i
+ 0];
11418 const char p1
= clichall_pos
[i
+ 1];
11420 *chall_ptr
++ = hex_convert (p1
) << 0
11421 | hex_convert (p0
) << 4;
11428 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11430 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11432 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11434 salt
->salt_len
= salt_len
;
11436 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11437 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11438 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11439 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11441 digest
[0] = byte_swap_32 (digest
[0]);
11442 digest
[1] = byte_swap_32 (digest
[1]);
11443 digest
[2] = byte_swap_32 (digest
[2]);
11444 digest
[3] = byte_swap_32 (digest
[3]);
11446 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11448 uint digest_tmp
[2] = { 0 };
11450 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11451 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11453 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11454 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11456 /* special case 2: ESS */
11458 if (srvchall_len
== 48)
11460 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11462 uint w
[16] = { 0 };
11464 w
[ 0] = netntlm
->chall_buf
[6];
11465 w
[ 1] = netntlm
->chall_buf
[7];
11466 w
[ 2] = netntlm
->chall_buf
[0];
11467 w
[ 3] = netntlm
->chall_buf
[1];
11471 uint dgst
[4] = { 0 };
11480 salt
->salt_buf
[0] = dgst
[0];
11481 salt
->salt_buf
[1] = dgst
[1];
11485 /* precompute netntlmv1 exploit start */
11487 for (uint i
= 0; i
< 0x10000; i
++)
11489 uint key_md4
[2] = { i
, 0 };
11490 uint key_des
[2] = { 0, 0 };
11492 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11494 uint Kc
[16] = { 0 };
11495 uint Kd
[16] = { 0 };
11497 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11499 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11501 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11503 if (data3
[0] != digest_tmp
[0]) continue;
11504 if (data3
[1] != digest_tmp
[1]) continue;
11506 salt
->salt_buf
[2] = i
;
11508 salt
->salt_len
= 24;
11513 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11514 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11516 /* precompute netntlmv1 exploit stop */
11520 IP (digest
[0], digest
[1], tt
);
11521 IP (digest
[2], digest
[3], tt
);
11523 digest
[0] = rotr32 (digest
[0], 29);
11524 digest
[1] = rotr32 (digest
[1], 29);
11525 digest
[2] = rotr32 (digest
[2], 29);
11526 digest
[3] = rotr32 (digest
[3], 29);
11528 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11530 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11531 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11533 return (PARSER_OK
);
11536 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11538 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11540 u32
*digest
= (u32
*) hash_buf
->digest
;
11542 salt_t
*salt
= hash_buf
->salt
;
11544 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11550 char *user_pos
= input_buf
;
11552 char *unused_pos
= strchr (user_pos
, ':');
11554 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11556 uint user_len
= unused_pos
- user_pos
;
11558 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11562 char *domain_pos
= strchr (unused_pos
, ':');
11564 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11566 uint unused_len
= domain_pos
- unused_pos
;
11568 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11572 char *srvchall_pos
= strchr (domain_pos
, ':');
11574 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11576 uint domain_len
= srvchall_pos
- domain_pos
;
11578 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11582 char *hash_pos
= strchr (srvchall_pos
, ':');
11584 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11586 uint srvchall_len
= hash_pos
- srvchall_pos
;
11588 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11592 char *clichall_pos
= strchr (hash_pos
, ':');
11594 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11596 uint hash_len
= clichall_pos
- hash_pos
;
11598 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11602 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11604 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11606 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11609 * store some data for later use
11612 netntlm
->user_len
= user_len
* 2;
11613 netntlm
->domain_len
= domain_len
* 2;
11614 netntlm
->srvchall_len
= srvchall_len
/ 2;
11615 netntlm
->clichall_len
= clichall_len
/ 2;
11617 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11618 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11621 * handle username and domainname
11624 for (uint i
= 0; i
< user_len
; i
++)
11626 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11627 *userdomain_ptr
++ = 0;
11630 for (uint i
= 0; i
< domain_len
; i
++)
11632 *userdomain_ptr
++ = domain_pos
[i
];
11633 *userdomain_ptr
++ = 0;
11636 *userdomain_ptr
++ = 0x80;
11639 * handle server challenge encoding
11642 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11644 const char p0
= srvchall_pos
[i
+ 0];
11645 const char p1
= srvchall_pos
[i
+ 1];
11647 *chall_ptr
++ = hex_convert (p1
) << 0
11648 | hex_convert (p0
) << 4;
11652 * handle client challenge encoding
11655 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11657 const char p0
= clichall_pos
[i
+ 0];
11658 const char p1
= clichall_pos
[i
+ 1];
11660 *chall_ptr
++ = hex_convert (p1
) << 0
11661 | hex_convert (p0
) << 4;
11664 *chall_ptr
++ = 0x80;
11667 * handle hash itself
11670 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11671 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11672 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11673 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11675 digest
[0] = byte_swap_32 (digest
[0]);
11676 digest
[1] = byte_swap_32 (digest
[1]);
11677 digest
[2] = byte_swap_32 (digest
[2]);
11678 digest
[3] = byte_swap_32 (digest
[3]);
11681 * reuse challange data as salt_buf, its the buffer that is most likely unique
11684 salt
->salt_buf
[0] = 0;
11685 salt
->salt_buf
[1] = 0;
11686 salt
->salt_buf
[2] = 0;
11687 salt
->salt_buf
[3] = 0;
11688 salt
->salt_buf
[4] = 0;
11689 salt
->salt_buf
[5] = 0;
11690 salt
->salt_buf
[6] = 0;
11691 salt
->salt_buf
[7] = 0;
11695 uptr
= (uint
*) netntlm
->userdomain_buf
;
11697 for (uint i
= 0; i
< 16; i
+= 16)
11699 md5_64 (uptr
, salt
->salt_buf
);
11702 uptr
= (uint
*) netntlm
->chall_buf
;
11704 for (uint i
= 0; i
< 256; i
+= 16)
11706 md5_64 (uptr
, salt
->salt_buf
);
11709 salt
->salt_len
= 16;
11711 return (PARSER_OK
);
11714 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11716 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11718 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11722 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11725 u32
*digest
= (u32
*) hash_buf
->digest
;
11727 salt_t
*salt
= hash_buf
->salt
;
11729 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11730 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11731 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11732 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11734 digest
[0] = byte_swap_32 (digest
[0]);
11735 digest
[1] = byte_swap_32 (digest
[1]);
11736 digest
[2] = byte_swap_32 (digest
[2]);
11737 digest
[3] = byte_swap_32 (digest
[3]);
11739 digest
[0] -= MD5M_A
;
11740 digest
[1] -= MD5M_B
;
11741 digest
[2] -= MD5M_C
;
11742 digest
[3] -= MD5M_D
;
11744 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11746 uint salt_len
= input_len
- 32 - 1;
11748 char *salt_buf
= input_buf
+ 32 + 1;
11750 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11752 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11754 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11756 salt
->salt_len
= salt_len
;
11758 return (PARSER_OK
);
11761 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11763 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11765 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11769 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11772 u32
*digest
= (u32
*) hash_buf
->digest
;
11774 salt_t
*salt
= hash_buf
->salt
;
11776 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11777 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11778 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11779 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11781 digest
[0] = byte_swap_32 (digest
[0]);
11782 digest
[1] = byte_swap_32 (digest
[1]);
11783 digest
[2] = byte_swap_32 (digest
[2]);
11784 digest
[3] = byte_swap_32 (digest
[3]);
11786 digest
[0] -= MD5M_A
;
11787 digest
[1] -= MD5M_B
;
11788 digest
[2] -= MD5M_C
;
11789 digest
[3] -= MD5M_D
;
11791 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11793 uint salt_len
= input_len
- 32 - 1;
11795 char *salt_buf
= input_buf
+ 32 + 1;
11797 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11799 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11801 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11803 salt
->salt_len
= salt_len
;
11805 return (PARSER_OK
);
11808 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11810 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11812 u32
*digest
= (u32
*) hash_buf
->digest
;
11814 salt_t
*salt
= hash_buf
->salt
;
11816 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11817 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11818 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11819 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11821 digest
[0] = byte_swap_32 (digest
[0]);
11822 digest
[1] = byte_swap_32 (digest
[1]);
11823 digest
[2] = byte_swap_32 (digest
[2]);
11824 digest
[3] = byte_swap_32 (digest
[3]);
11826 digest
[0] -= MD5M_A
;
11827 digest
[1] -= MD5M_B
;
11828 digest
[2] -= MD5M_C
;
11829 digest
[3] -= MD5M_D
;
11832 * This is a virtual salt. While the algorithm is basically not salted
11833 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11834 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11837 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11839 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11841 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11843 salt
->salt_len
= salt_len
;
11845 return (PARSER_OK
);
11848 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11850 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11852 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11856 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11859 u32
*digest
= (u32
*) hash_buf
->digest
;
11861 salt_t
*salt
= hash_buf
->salt
;
11863 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11864 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11865 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11866 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11868 digest
[0] = byte_swap_32 (digest
[0]);
11869 digest
[1] = byte_swap_32 (digest
[1]);
11870 digest
[2] = byte_swap_32 (digest
[2]);
11871 digest
[3] = byte_swap_32 (digest
[3]);
11873 digest
[0] -= MD5M_A
;
11874 digest
[1] -= MD5M_B
;
11875 digest
[2] -= MD5M_C
;
11876 digest
[3] -= MD5M_D
;
11878 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11880 uint salt_len
= input_len
- 32 - 1;
11882 char *salt_buf
= input_buf
+ 32 + 1;
11884 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11886 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11888 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11890 salt
->salt_len
= salt_len
;
11892 return (PARSER_OK
);
11895 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11897 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11899 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11903 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11906 u32
*digest
= (u32
*) hash_buf
->digest
;
11908 salt_t
*salt
= hash_buf
->salt
;
11910 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11911 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11912 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11913 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11915 digest
[0] = byte_swap_32 (digest
[0]);
11916 digest
[1] = byte_swap_32 (digest
[1]);
11917 digest
[2] = byte_swap_32 (digest
[2]);
11918 digest
[3] = byte_swap_32 (digest
[3]);
11920 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11922 uint salt_len
= input_len
- 32 - 1;
11924 char *salt_buf
= input_buf
+ 32 + 1;
11926 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11928 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11930 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11932 salt
->salt_len
= salt_len
;
11934 return (PARSER_OK
);
11937 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11939 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11941 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11945 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11948 u32
*digest
= (u32
*) hash_buf
->digest
;
11950 salt_t
*salt
= hash_buf
->salt
;
11952 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11953 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11954 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11955 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11957 digest
[0] = byte_swap_32 (digest
[0]);
11958 digest
[1] = byte_swap_32 (digest
[1]);
11959 digest
[2] = byte_swap_32 (digest
[2]);
11960 digest
[3] = byte_swap_32 (digest
[3]);
11962 digest
[0] -= MD4M_A
;
11963 digest
[1] -= MD4M_B
;
11964 digest
[2] -= MD4M_C
;
11965 digest
[3] -= MD4M_D
;
11967 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11969 uint salt_len
= input_len
- 32 - 1;
11971 char *salt_buf
= input_buf
+ 32 + 1;
11973 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11975 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11977 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11979 salt
->salt_len
= salt_len
;
11981 return (PARSER_OK
);
11984 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11986 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11988 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11992 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11995 u32
*digest
= (u32
*) hash_buf
->digest
;
11997 salt_t
*salt
= hash_buf
->salt
;
11999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12004 digest
[0] = byte_swap_32 (digest
[0]);
12005 digest
[1] = byte_swap_32 (digest
[1]);
12006 digest
[2] = byte_swap_32 (digest
[2]);
12007 digest
[3] = byte_swap_32 (digest
[3]);
12009 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12011 uint salt_len
= input_len
- 32 - 1;
12013 char *salt_buf
= input_buf
+ 32 + 1;
12015 uint salt_pc_block
[16] = { 0 };
12017 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12019 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12021 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12023 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12025 salt_pc_block
[14] = salt_len
* 8;
12027 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12029 md5_64 (salt_pc_block
, salt_pc_digest
);
12031 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12032 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12033 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12034 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12036 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12038 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12040 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12042 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12043 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12044 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12045 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12047 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12049 return (PARSER_OK
);
12052 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12054 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12056 u32
*digest
= (u32
*) hash_buf
->digest
;
12058 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12059 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12060 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12061 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12062 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12064 digest
[0] -= SHA1M_A
;
12065 digest
[1] -= SHA1M_B
;
12066 digest
[2] -= SHA1M_C
;
12067 digest
[3] -= SHA1M_D
;
12068 digest
[4] -= SHA1M_E
;
12070 return (PARSER_OK
);
12073 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12075 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12077 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12079 u32
*digest
= (u32
*) hash_buf
->digest
;
12083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12089 return (PARSER_OK
);
12092 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12094 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12096 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12100 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12103 u32
*digest
= (u32
*) hash_buf
->digest
;
12105 salt_t
*salt
= hash_buf
->salt
;
12107 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12108 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12109 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12110 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12111 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12113 digest
[0] -= SHA1M_A
;
12114 digest
[1] -= SHA1M_B
;
12115 digest
[2] -= SHA1M_C
;
12116 digest
[3] -= SHA1M_D
;
12117 digest
[4] -= SHA1M_E
;
12119 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12121 uint salt_len
= input_len
- 40 - 1;
12123 char *salt_buf
= input_buf
+ 40 + 1;
12125 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12127 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12129 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12131 salt
->salt_len
= salt_len
;
12133 return (PARSER_OK
);
12136 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12138 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12140 u32
*digest
= (u32
*) hash_buf
->digest
;
12142 salt_t
*salt
= hash_buf
->salt
;
12144 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12146 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12147 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12148 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12149 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12150 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12152 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12154 uint salt_len
= input_len
- 40 - 1;
12156 char *salt_buf
= input_buf
+ 40 + 1;
12158 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12160 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12162 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12164 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12167 pstoken
->salt_len
= salt_len
/ 2;
12169 /* some fake salt for the sorting mechanisms */
12171 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12172 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12173 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12174 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12175 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12176 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12177 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12178 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12180 salt
->salt_len
= 32;
12182 /* we need to check if we can precompute some of the data --
12183 this is possible since the scheme is badly designed */
12185 pstoken
->pc_digest
[0] = SHA1M_A
;
12186 pstoken
->pc_digest
[1] = SHA1M_B
;
12187 pstoken
->pc_digest
[2] = SHA1M_C
;
12188 pstoken
->pc_digest
[3] = SHA1M_D
;
12189 pstoken
->pc_digest
[4] = SHA1M_E
;
12191 pstoken
->pc_offset
= 0;
12193 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12197 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12198 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12199 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12200 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12201 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12202 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12203 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12204 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12205 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12206 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12207 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12208 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12209 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12210 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12211 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12212 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12214 sha1_64 (w
, pstoken
->pc_digest
);
12216 pstoken
->pc_offset
+= 16;
12219 return (PARSER_OK
);
12222 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12224 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12226 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12228 u32
*digest
= (u32
*) hash_buf
->digest
;
12230 u8 tmp_buf
[100] = { 0 };
12232 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12234 memcpy (digest
, tmp_buf
, 20);
12236 digest
[0] = byte_swap_32 (digest
[0]);
12237 digest
[1] = byte_swap_32 (digest
[1]);
12238 digest
[2] = byte_swap_32 (digest
[2]);
12239 digest
[3] = byte_swap_32 (digest
[3]);
12240 digest
[4] = byte_swap_32 (digest
[4]);
12242 digest
[0] -= SHA1M_A
;
12243 digest
[1] -= SHA1M_B
;
12244 digest
[2] -= SHA1M_C
;
12245 digest
[3] -= SHA1M_D
;
12246 digest
[4] -= SHA1M_E
;
12248 return (PARSER_OK
);
12251 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12253 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12255 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12257 u32
*digest
= (u32
*) hash_buf
->digest
;
12259 salt_t
*salt
= hash_buf
->salt
;
12261 u8 tmp_buf
[100] = { 0 };
12263 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12265 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12267 memcpy (digest
, tmp_buf
, 20);
12269 int salt_len
= tmp_len
- 20;
12271 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12273 salt
->salt_len
= salt_len
;
12275 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12277 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12279 char *ptr
= (char *) salt
->salt_buf
;
12281 ptr
[salt
->salt_len
] = 0x80;
12284 digest
[0] = byte_swap_32 (digest
[0]);
12285 digest
[1] = byte_swap_32 (digest
[1]);
12286 digest
[2] = byte_swap_32 (digest
[2]);
12287 digest
[3] = byte_swap_32 (digest
[3]);
12288 digest
[4] = byte_swap_32 (digest
[4]);
12290 digest
[0] -= SHA1M_A
;
12291 digest
[1] -= SHA1M_B
;
12292 digest
[2] -= SHA1M_C
;
12293 digest
[3] -= SHA1M_D
;
12294 digest
[4] -= SHA1M_E
;
12296 return (PARSER_OK
);
12299 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12301 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12303 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12305 u32
*digest
= (u32
*) hash_buf
->digest
;
12307 salt_t
*salt
= hash_buf
->salt
;
12309 char *salt_buf
= input_buf
+ 6;
12313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12319 salt
->salt_len
= salt_len
;
12321 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12323 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12324 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12325 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12326 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12327 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12329 digest
[0] -= SHA1M_A
;
12330 digest
[1] -= SHA1M_B
;
12331 digest
[2] -= SHA1M_C
;
12332 digest
[3] -= SHA1M_D
;
12333 digest
[4] -= SHA1M_E
;
12335 return (PARSER_OK
);
12338 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12340 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12342 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12344 u32
*digest
= (u32
*) hash_buf
->digest
;
12346 salt_t
*salt
= hash_buf
->salt
;
12348 char *salt_buf
= input_buf
+ 6;
12352 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12354 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12356 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12358 salt
->salt_len
= salt_len
;
12360 char *hash_pos
= input_buf
+ 6 + 8;
12362 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12363 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12364 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12365 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12366 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12368 digest
[0] -= SHA1M_A
;
12369 digest
[1] -= SHA1M_B
;
12370 digest
[2] -= SHA1M_C
;
12371 digest
[3] -= SHA1M_D
;
12372 digest
[4] -= SHA1M_E
;
12374 return (PARSER_OK
);
12377 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12381 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12383 u64
*digest
= (u64
*) hash_buf
->digest
;
12385 salt_t
*salt
= hash_buf
->salt
;
12387 char *salt_buf
= input_buf
+ 6;
12391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12393 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12397 salt
->salt_len
= salt_len
;
12399 char *hash_pos
= input_buf
+ 6 + 8;
12401 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12402 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12403 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12404 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12405 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12406 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12407 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12408 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12410 digest
[0] -= SHA512M_A
;
12411 digest
[1] -= SHA512M_B
;
12412 digest
[2] -= SHA512M_C
;
12413 digest
[3] -= SHA512M_D
;
12414 digest
[4] -= SHA512M_E
;
12415 digest
[5] -= SHA512M_F
;
12416 digest
[6] -= SHA512M_G
;
12417 digest
[7] -= SHA512M_H
;
12419 return (PARSER_OK
);
12422 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12424 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12426 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12430 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12433 u32
*digest
= (u32
*) hash_buf
->digest
;
12435 salt_t
*salt
= hash_buf
->salt
;
12437 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12438 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12442 digest
[0] = byte_swap_32 (digest
[0]);
12443 digest
[1] = byte_swap_32 (digest
[1]);
12445 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12447 uint salt_len
= input_len
- 16 - 1;
12449 char *salt_buf
= input_buf
+ 16 + 1;
12451 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12453 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12455 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12457 salt
->salt_len
= salt_len
;
12459 return (PARSER_OK
);
12462 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12464 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12466 u32
*digest
= (u32
*) hash_buf
->digest
;
12468 salt_t
*salt
= hash_buf
->salt
;
12470 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12471 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12472 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12473 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12474 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12476 digest
[0] -= SHA1M_A
;
12477 digest
[1] -= SHA1M_B
;
12478 digest
[2] -= SHA1M_C
;
12479 digest
[3] -= SHA1M_D
;
12480 digest
[4] -= SHA1M_E
;
12482 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12484 uint salt_len
= input_len
- 40 - 1;
12486 char *salt_buf
= input_buf
+ 40 + 1;
12488 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12490 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12492 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12494 salt
->salt_len
= salt_len
;
12496 return (PARSER_OK
);
12499 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12501 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12503 u32
*digest
= (u32
*) hash_buf
->digest
;
12505 salt_t
*salt
= hash_buf
->salt
;
12507 char *hash_pos
= input_buf
;
12509 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12510 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12511 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12512 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12513 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12514 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12515 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12516 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12517 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12518 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12519 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12520 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12521 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12522 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12523 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12524 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12526 char *salt_pos
= input_buf
+ 128;
12528 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12529 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12530 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12531 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12533 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12534 salt
->salt_len
= 16;
12536 return (PARSER_OK
);
12539 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12541 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12543 u32
*digest
= (u32
*) hash_buf
->digest
;
12545 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12546 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12547 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12548 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12549 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12550 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12551 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12552 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12554 digest
[0] -= SHA256M_A
;
12555 digest
[1] -= SHA256M_B
;
12556 digest
[2] -= SHA256M_C
;
12557 digest
[3] -= SHA256M_D
;
12558 digest
[4] -= SHA256M_E
;
12559 digest
[5] -= SHA256M_F
;
12560 digest
[6] -= SHA256M_G
;
12561 digest
[7] -= SHA256M_H
;
12563 return (PARSER_OK
);
12566 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12570 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12574 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12577 u32
*digest
= (u32
*) hash_buf
->digest
;
12579 salt_t
*salt
= hash_buf
->salt
;
12581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12585 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12586 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12587 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12588 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12590 digest
[0] -= SHA256M_A
;
12591 digest
[1] -= SHA256M_B
;
12592 digest
[2] -= SHA256M_C
;
12593 digest
[3] -= SHA256M_D
;
12594 digest
[4] -= SHA256M_E
;
12595 digest
[5] -= SHA256M_F
;
12596 digest
[6] -= SHA256M_G
;
12597 digest
[7] -= SHA256M_H
;
12599 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12601 uint salt_len
= input_len
- 64 - 1;
12603 char *salt_buf
= input_buf
+ 64 + 1;
12605 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12607 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12609 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12611 salt
->salt_len
= salt_len
;
12613 return (PARSER_OK
);
12616 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12618 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12620 u64
*digest
= (u64
*) hash_buf
->digest
;
12622 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12623 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12624 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12625 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12626 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12627 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12631 digest
[0] -= SHA384M_A
;
12632 digest
[1] -= SHA384M_B
;
12633 digest
[2] -= SHA384M_C
;
12634 digest
[3] -= SHA384M_D
;
12635 digest
[4] -= SHA384M_E
;
12636 digest
[5] -= SHA384M_F
;
12640 return (PARSER_OK
);
12643 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12645 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12647 u64
*digest
= (u64
*) hash_buf
->digest
;
12649 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12650 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12651 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12652 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12653 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12654 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12655 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12656 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12658 digest
[0] -= SHA512M_A
;
12659 digest
[1] -= SHA512M_B
;
12660 digest
[2] -= SHA512M_C
;
12661 digest
[3] -= SHA512M_D
;
12662 digest
[4] -= SHA512M_E
;
12663 digest
[5] -= SHA512M_F
;
12664 digest
[6] -= SHA512M_G
;
12665 digest
[7] -= SHA512M_H
;
12667 return (PARSER_OK
);
12670 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12672 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12674 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12678 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12681 u64
*digest
= (u64
*) hash_buf
->digest
;
12683 salt_t
*salt
= hash_buf
->salt
;
12685 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12686 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12687 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12688 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12689 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12690 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12691 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12692 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12694 digest
[0] -= SHA512M_A
;
12695 digest
[1] -= SHA512M_B
;
12696 digest
[2] -= SHA512M_C
;
12697 digest
[3] -= SHA512M_D
;
12698 digest
[4] -= SHA512M_E
;
12699 digest
[5] -= SHA512M_F
;
12700 digest
[6] -= SHA512M_G
;
12701 digest
[7] -= SHA512M_H
;
12703 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12705 uint salt_len
= input_len
- 128 - 1;
12707 char *salt_buf
= input_buf
+ 128 + 1;
12709 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12711 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12713 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12715 salt
->salt_len
= salt_len
;
12717 return (PARSER_OK
);
12720 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12722 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12724 u64
*digest
= (u64
*) hash_buf
->digest
;
12726 salt_t
*salt
= hash_buf
->salt
;
12728 char *salt_pos
= input_buf
+ 3;
12730 uint iterations_len
= 0;
12732 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12736 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12738 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12739 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12743 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12747 iterations_len
+= 8;
12751 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12754 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12756 char *hash_pos
= strchr (salt_pos
, '$');
12758 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12760 uint salt_len
= hash_pos
- salt_pos
;
12762 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12764 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12766 salt
->salt_len
= salt_len
;
12770 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12772 return (PARSER_OK
);
12775 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12777 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12779 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12781 u64
*digest
= (u64
*) hash_buf
->digest
;
12783 salt_t
*salt
= hash_buf
->salt
;
12785 uint keccak_mdlen
= input_len
/ 2;
12787 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12789 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12791 digest
[i
] = byte_swap_64 (digest
[i
]);
12794 salt
->keccak_mdlen
= keccak_mdlen
;
12796 return (PARSER_OK
);
12799 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12801 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12803 u32
*digest
= (u32
*) hash_buf
->digest
;
12805 salt_t
*salt
= hash_buf
->salt
;
12807 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12810 * Parse that strange long line
12815 size_t in_len
[9] = { 0 };
12817 in_off
[0] = strtok (input_buf
, ":");
12819 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12821 in_len
[0] = strlen (in_off
[0]);
12825 for (i
= 1; i
< 9; i
++)
12827 in_off
[i
] = strtok (NULL
, ":");
12829 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12831 in_len
[i
] = strlen (in_off
[i
]);
12834 char *ptr
= (char *) ikepsk
->msg_buf
;
12836 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12837 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12838 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12839 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12840 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12841 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12845 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12847 ptr
= (char *) ikepsk
->nr_buf
;
12849 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12850 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12854 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12857 * Store to database
12862 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12863 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12864 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12865 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12867 digest
[0] = byte_swap_32 (digest
[0]);
12868 digest
[1] = byte_swap_32 (digest
[1]);
12869 digest
[2] = byte_swap_32 (digest
[2]);
12870 digest
[3] = byte_swap_32 (digest
[3]);
12872 salt
->salt_len
= 32;
12874 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12875 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12876 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12877 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12878 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12879 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12880 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12881 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12883 return (PARSER_OK
);
12886 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12888 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12890 u32
*digest
= (u32
*) hash_buf
->digest
;
12892 salt_t
*salt
= hash_buf
->salt
;
12894 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12897 * Parse that strange long line
12902 size_t in_len
[9] = { 0 };
12904 in_off
[0] = strtok (input_buf
, ":");
12906 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12908 in_len
[0] = strlen (in_off
[0]);
12912 for (i
= 1; i
< 9; i
++)
12914 in_off
[i
] = strtok (NULL
, ":");
12916 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12918 in_len
[i
] = strlen (in_off
[i
]);
12921 char *ptr
= (char *) ikepsk
->msg_buf
;
12923 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12924 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12925 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12926 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12927 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12928 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12932 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12934 ptr
= (char *) ikepsk
->nr_buf
;
12936 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12937 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12941 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12944 * Store to database
12949 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12950 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12951 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12952 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12953 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12955 salt
->salt_len
= 32;
12957 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12958 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12959 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12960 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12961 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12962 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12963 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12964 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12966 return (PARSER_OK
);
12969 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12971 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12973 u32
*digest
= (u32
*) hash_buf
->digest
;
12975 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12976 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12977 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12978 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12979 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12981 digest
[0] = byte_swap_32 (digest
[0]);
12982 digest
[1] = byte_swap_32 (digest
[1]);
12983 digest
[2] = byte_swap_32 (digest
[2]);
12984 digest
[3] = byte_swap_32 (digest
[3]);
12985 digest
[4] = byte_swap_32 (digest
[4]);
12987 return (PARSER_OK
);
12990 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12992 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12994 u32
*digest
= (u32
*) hash_buf
->digest
;
12996 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12997 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12998 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12999 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13000 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13001 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13002 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13003 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13004 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13005 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13006 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13007 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13008 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13009 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13010 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13011 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13013 return (PARSER_OK
);
13016 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13018 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13020 u32
*digest
= (u32
*) hash_buf
->digest
;
13022 salt_t
*salt
= hash_buf
->salt
;
13024 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13025 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13026 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13027 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13028 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13030 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13032 uint salt_len
= input_len
- 40 - 1;
13034 char *salt_buf
= input_buf
+ 40 + 1;
13036 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13038 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13040 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13042 salt
->salt_len
= salt_len
;
13044 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13046 return (PARSER_OK
);
13049 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13051 u32
*digest
= (u32
*) hash_buf
->digest
;
13053 salt_t
*salt
= hash_buf
->salt
;
13055 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13057 if (input_len
== 0)
13059 log_error ("TrueCrypt container not specified");
13064 FILE *fp
= fopen (input_buf
, "rb");
13068 log_error ("%s: %s", input_buf
, strerror (errno
));
13073 char buf
[512] = { 0 };
13075 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13079 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13081 memcpy (tc
->salt_buf
, buf
, 64);
13083 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13085 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13087 salt
->salt_len
= 4;
13089 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13091 tc
->signature
= 0x45555254; // "TRUE"
13093 digest
[0] = tc
->data_buf
[0];
13095 return (PARSER_OK
);
13098 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13100 u32
*digest
= (u32
*) hash_buf
->digest
;
13102 salt_t
*salt
= hash_buf
->salt
;
13104 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13106 if (input_len
== 0)
13108 log_error ("TrueCrypt container not specified");
13113 FILE *fp
= fopen (input_buf
, "rb");
13117 log_error ("%s: %s", input_buf
, strerror (errno
));
13122 char buf
[512] = { 0 };
13124 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13128 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13130 memcpy (tc
->salt_buf
, buf
, 64);
13132 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13134 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13136 salt
->salt_len
= 4;
13138 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13140 tc
->signature
= 0x45555254; // "TRUE"
13142 digest
[0] = tc
->data_buf
[0];
13144 return (PARSER_OK
);
13147 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13149 u32
*digest
= (u32
*) hash_buf
->digest
;
13151 salt_t
*salt
= hash_buf
->salt
;
13153 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13155 if (input_len
== 0)
13157 log_error ("VeraCrypt container not specified");
13162 FILE *fp
= fopen (input_buf
, "rb");
13166 log_error ("%s: %s", input_buf
, strerror (errno
));
13171 char buf
[512] = { 0 };
13173 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13177 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13179 memcpy (tc
->salt_buf
, buf
, 64);
13181 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13183 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13185 salt
->salt_len
= 4;
13187 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13189 tc
->signature
= 0x41524556; // "VERA"
13191 digest
[0] = tc
->data_buf
[0];
13193 return (PARSER_OK
);
13196 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13198 u32
*digest
= (u32
*) hash_buf
->digest
;
13200 salt_t
*salt
= hash_buf
->salt
;
13202 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13204 if (input_len
== 0)
13206 log_error ("VeraCrypt container not specified");
13211 FILE *fp
= fopen (input_buf
, "rb");
13215 log_error ("%s: %s", input_buf
, strerror (errno
));
13220 char buf
[512] = { 0 };
13222 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13226 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13228 memcpy (tc
->salt_buf
, buf
, 64);
13230 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13232 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13234 salt
->salt_len
= 4;
13236 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13238 tc
->signature
= 0x41524556; // "VERA"
13240 digest
[0] = tc
->data_buf
[0];
13242 return (PARSER_OK
);
13245 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13247 u32
*digest
= (u32
*) hash_buf
->digest
;
13249 salt_t
*salt
= hash_buf
->salt
;
13251 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13253 if (input_len
== 0)
13255 log_error ("VeraCrypt container not specified");
13260 FILE *fp
= fopen (input_buf
, "rb");
13264 log_error ("%s: %s", input_buf
, strerror (errno
));
13269 char buf
[512] = { 0 };
13271 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13275 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13277 memcpy (tc
->salt_buf
, buf
, 64);
13279 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13281 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13283 salt
->salt_len
= 4;
13285 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13287 tc
->signature
= 0x41524556; // "VERA"
13289 digest
[0] = tc
->data_buf
[0];
13291 return (PARSER_OK
);
13294 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13296 u32
*digest
= (u32
*) hash_buf
->digest
;
13298 salt_t
*salt
= hash_buf
->salt
;
13300 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13302 if (input_len
== 0)
13304 log_error ("VeraCrypt container not specified");
13309 FILE *fp
= fopen (input_buf
, "rb");
13313 log_error ("%s: %s", input_buf
, strerror (errno
));
13318 char buf
[512] = { 0 };
13320 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13324 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13326 memcpy (tc
->salt_buf
, buf
, 64);
13328 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13330 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13332 salt
->salt_len
= 4;
13334 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13336 tc
->signature
= 0x41524556; // "VERA"
13338 digest
[0] = tc
->data_buf
[0];
13340 return (PARSER_OK
);
13343 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13345 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13347 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13349 u32
*digest
= (u32
*) hash_buf
->digest
;
13351 salt_t
*salt
= hash_buf
->salt
;
13353 char *salt_pos
= input_buf
+ 6;
13355 char *hash_pos
= strchr (salt_pos
, '$');
13357 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13359 uint salt_len
= hash_pos
- salt_pos
;
13361 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13363 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13365 salt
->salt_len
= salt_len
;
13367 salt
->salt_iter
= 1000;
13371 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13373 return (PARSER_OK
);
13376 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13378 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13380 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13382 u32
*digest
= (u32
*) hash_buf
->digest
;
13384 salt_t
*salt
= hash_buf
->salt
;
13386 char *iter_pos
= input_buf
+ 7;
13388 char *salt_pos
= strchr (iter_pos
, '$');
13390 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13394 char *hash_pos
= strchr (salt_pos
, '$');
13396 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13398 uint salt_len
= hash_pos
- salt_pos
;
13400 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13402 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13404 salt
->salt_len
= salt_len
;
13406 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13408 salt
->salt_sign
[0] = atoi (salt_iter
);
13410 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13414 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13416 digest
[0] = byte_swap_32 (digest
[0]);
13417 digest
[1] = byte_swap_32 (digest
[1]);
13418 digest
[2] = byte_swap_32 (digest
[2]);
13419 digest
[3] = byte_swap_32 (digest
[3]);
13420 digest
[4] = byte_swap_32 (digest
[4]);
13422 return (PARSER_OK
);
13425 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13427 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13429 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13431 u32
*digest
= (u32
*) hash_buf
->digest
;
13433 salt_t
*salt
= hash_buf
->salt
;
13435 char *iter_pos
= input_buf
+ 9;
13437 char *salt_pos
= strchr (iter_pos
, '$');
13439 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13443 char *hash_pos
= strchr (salt_pos
, '$');
13445 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13447 uint salt_len
= hash_pos
- salt_pos
;
13449 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13451 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13453 salt
->salt_len
= salt_len
;
13455 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13457 salt
->salt_sign
[0] = atoi (salt_iter
);
13459 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13463 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13465 digest
[0] = byte_swap_32 (digest
[0]);
13466 digest
[1] = byte_swap_32 (digest
[1]);
13467 digest
[2] = byte_swap_32 (digest
[2]);
13468 digest
[3] = byte_swap_32 (digest
[3]);
13469 digest
[4] = byte_swap_32 (digest
[4]);
13470 digest
[5] = byte_swap_32 (digest
[5]);
13471 digest
[6] = byte_swap_32 (digest
[6]);
13472 digest
[7] = byte_swap_32 (digest
[7]);
13474 return (PARSER_OK
);
13477 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13479 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13481 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13483 u64
*digest
= (u64
*) hash_buf
->digest
;
13485 salt_t
*salt
= hash_buf
->salt
;
13487 char *iter_pos
= input_buf
+ 9;
13489 char *salt_pos
= strchr (iter_pos
, '$');
13491 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13495 char *hash_pos
= strchr (salt_pos
, '$');
13497 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13499 uint salt_len
= hash_pos
- salt_pos
;
13501 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13503 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13505 salt
->salt_len
= salt_len
;
13507 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13509 salt
->salt_sign
[0] = atoi (salt_iter
);
13511 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13515 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13517 digest
[0] = byte_swap_64 (digest
[0]);
13518 digest
[1] = byte_swap_64 (digest
[1]);
13519 digest
[2] = byte_swap_64 (digest
[2]);
13520 digest
[3] = byte_swap_64 (digest
[3]);
13521 digest
[4] = byte_swap_64 (digest
[4]);
13522 digest
[5] = byte_swap_64 (digest
[5]);
13523 digest
[6] = byte_swap_64 (digest
[6]);
13524 digest
[7] = byte_swap_64 (digest
[7]);
13526 return (PARSER_OK
);
13529 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13531 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13533 u32
*digest
= (u32
*) hash_buf
->digest
;
13535 salt_t
*salt
= hash_buf
->salt
;
13537 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13543 char *iterations_pos
= input_buf
;
13545 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13547 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13549 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13551 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13555 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13557 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13559 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13561 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13563 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13565 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13570 * pbkdf2 iterations
13573 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13576 * handle salt encoding
13579 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13581 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13583 const char p0
= saltbuf_pos
[i
+ 0];
13584 const char p1
= saltbuf_pos
[i
+ 1];
13586 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13587 | hex_convert (p0
) << 4;
13590 salt
->salt_len
= saltbuf_len
/ 2;
13593 * handle cipher encoding
13596 uint
*tmp
= (uint
*) mymalloc (32);
13598 char *cipherbuf_ptr
= (char *) tmp
;
13600 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13602 const char p0
= cipherbuf_pos
[i
+ 0];
13603 const char p1
= cipherbuf_pos
[i
+ 1];
13605 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13606 | hex_convert (p0
) << 4;
13609 // iv is stored at salt_buf 4 (length 16)
13610 // data is stored at salt_buf 8 (length 16)
13612 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13613 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13614 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13615 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13617 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13618 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13619 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13620 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13624 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13626 const char p0
= cipherbuf_pos
[j
+ 0];
13627 const char p1
= cipherbuf_pos
[j
+ 1];
13629 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13630 | hex_convert (p0
) << 4;
13637 digest
[0] = 0x10101010;
13638 digest
[1] = 0x10101010;
13639 digest
[2] = 0x10101010;
13640 digest
[3] = 0x10101010;
13642 return (PARSER_OK
);
13645 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13647 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13649 u32
*digest
= (u32
*) hash_buf
->digest
;
13651 salt_t
*salt
= hash_buf
->salt
;
13653 char *hashbuf_pos
= input_buf
;
13655 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13657 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13659 uint hash_len
= iterations_pos
- hashbuf_pos
;
13661 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13665 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13667 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13669 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13673 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13675 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13677 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13679 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13681 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13683 salt
->salt_len
= salt_len
;
13685 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13687 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13688 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13689 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13690 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13692 return (PARSER_OK
);
13695 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13697 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13699 u32
*digest
= (u32
*) hash_buf
->digest
;
13701 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13702 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13703 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13704 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13705 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13706 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13707 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13708 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13710 digest
[0] = byte_swap_32 (digest
[0]);
13711 digest
[1] = byte_swap_32 (digest
[1]);
13712 digest
[2] = byte_swap_32 (digest
[2]);
13713 digest
[3] = byte_swap_32 (digest
[3]);
13714 digest
[4] = byte_swap_32 (digest
[4]);
13715 digest
[5] = byte_swap_32 (digest
[5]);
13716 digest
[6] = byte_swap_32 (digest
[6]);
13717 digest
[7] = byte_swap_32 (digest
[7]);
13719 return (PARSER_OK
);
13722 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13724 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13726 u32
*digest
= (u32
*) hash_buf
->digest
;
13728 salt_t
*salt
= hash_buf
->salt
;
13730 char *salt_pos
= input_buf
+ 3;
13732 uint iterations_len
= 0;
13734 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13738 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13740 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13741 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13745 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13749 iterations_len
+= 8;
13753 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13756 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13758 char *hash_pos
= strchr (salt_pos
, '$');
13760 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13762 uint salt_len
= hash_pos
- salt_pos
;
13764 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13766 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13768 salt
->salt_len
= salt_len
;
13772 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13774 return (PARSER_OK
);
13777 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13779 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13781 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13783 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13785 u64
*digest
= (u64
*) hash_buf
->digest
;
13787 salt_t
*salt
= hash_buf
->salt
;
13789 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13791 char *iter_pos
= input_buf
+ 4;
13793 char *salt_pos
= strchr (iter_pos
, '$');
13795 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13799 char *hash_pos
= strchr (salt_pos
, '$');
13801 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13803 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13807 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13808 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13809 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13810 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13811 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13812 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13813 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13814 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13816 uint salt_len
= hash_pos
- salt_pos
- 1;
13818 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13820 salt
->salt_len
= salt_len
/ 2;
13822 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13823 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13824 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13825 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13826 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13827 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13828 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13829 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13831 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13832 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13833 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13834 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13835 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13836 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13837 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13838 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13839 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13840 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13842 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13844 salt
->salt_iter
= atoi (iter_pos
) - 1;
13846 return (PARSER_OK
);
13849 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13851 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13853 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13855 u32
*digest
= (u32
*) hash_buf
->digest
;
13857 salt_t
*salt
= hash_buf
->salt
;
13859 char *salt_pos
= input_buf
+ 14;
13861 char *hash_pos
= strchr (salt_pos
, '*');
13863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13867 uint salt_len
= hash_pos
- salt_pos
- 1;
13869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13875 salt
->salt_len
= salt_len
;
13877 u8 tmp_buf
[100] = { 0 };
13879 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13881 memcpy (digest
, tmp_buf
, 32);
13883 digest
[0] = byte_swap_32 (digest
[0]);
13884 digest
[1] = byte_swap_32 (digest
[1]);
13885 digest
[2] = byte_swap_32 (digest
[2]);
13886 digest
[3] = byte_swap_32 (digest
[3]);
13887 digest
[4] = byte_swap_32 (digest
[4]);
13888 digest
[5] = byte_swap_32 (digest
[5]);
13889 digest
[6] = byte_swap_32 (digest
[6]);
13890 digest
[7] = byte_swap_32 (digest
[7]);
13892 digest
[0] -= SHA256M_A
;
13893 digest
[1] -= SHA256M_B
;
13894 digest
[2] -= SHA256M_C
;
13895 digest
[3] -= SHA256M_D
;
13896 digest
[4] -= SHA256M_E
;
13897 digest
[5] -= SHA256M_F
;
13898 digest
[6] -= SHA256M_G
;
13899 digest
[7] -= SHA256M_H
;
13901 return (PARSER_OK
);
13904 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13906 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13908 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13910 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13912 u64
*digest
= (u64
*) hash_buf
->digest
;
13914 salt_t
*salt
= hash_buf
->salt
;
13916 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13918 char *iter_pos
= input_buf
+ 19;
13920 char *salt_pos
= strchr (iter_pos
, '.');
13922 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13926 char *hash_pos
= strchr (salt_pos
, '.');
13928 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13930 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13934 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13935 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13936 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13937 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13938 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13939 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13940 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13941 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13943 uint salt_len
= hash_pos
- salt_pos
- 1;
13947 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13951 for (i
= 0; i
< salt_len
; i
++)
13953 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13956 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13957 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13959 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13961 salt
->salt_len
= salt_len
;
13963 salt
->salt_iter
= atoi (iter_pos
) - 1;
13965 return (PARSER_OK
);
13968 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13970 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13972 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13974 u64
*digest
= (u64
*) hash_buf
->digest
;
13976 salt_t
*salt
= hash_buf
->salt
;
13978 u8 tmp_buf
[120] = { 0 };
13980 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13982 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13984 memcpy (digest
, tmp_buf
, 64);
13986 digest
[0] = byte_swap_64 (digest
[0]);
13987 digest
[1] = byte_swap_64 (digest
[1]);
13988 digest
[2] = byte_swap_64 (digest
[2]);
13989 digest
[3] = byte_swap_64 (digest
[3]);
13990 digest
[4] = byte_swap_64 (digest
[4]);
13991 digest
[5] = byte_swap_64 (digest
[5]);
13992 digest
[6] = byte_swap_64 (digest
[6]);
13993 digest
[7] = byte_swap_64 (digest
[7]);
13995 digest
[0] -= SHA512M_A
;
13996 digest
[1] -= SHA512M_B
;
13997 digest
[2] -= SHA512M_C
;
13998 digest
[3] -= SHA512M_D
;
13999 digest
[4] -= SHA512M_E
;
14000 digest
[5] -= SHA512M_F
;
14001 digest
[6] -= SHA512M_G
;
14002 digest
[7] -= SHA512M_H
;
14004 int salt_len
= tmp_len
- 64;
14006 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14008 salt
->salt_len
= salt_len
;
14010 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14012 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14014 char *ptr
= (char *) salt
->salt_buf
;
14016 ptr
[salt
->salt_len
] = 0x80;
14019 return (PARSER_OK
);
14022 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14024 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14026 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14030 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14033 u32
*digest
= (u32
*) hash_buf
->digest
;
14035 salt_t
*salt
= hash_buf
->salt
;
14037 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14038 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14039 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14040 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14042 digest
[0] = byte_swap_32 (digest
[0]);
14043 digest
[1] = byte_swap_32 (digest
[1]);
14044 digest
[2] = byte_swap_32 (digest
[2]);
14045 digest
[3] = byte_swap_32 (digest
[3]);
14047 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14049 uint salt_len
= input_len
- 32 - 1;
14051 char *salt_buf
= input_buf
+ 32 + 1;
14053 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14055 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14057 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14059 salt
->salt_len
= salt_len
;
14061 return (PARSER_OK
);
14064 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14066 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14068 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14072 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14075 u32
*digest
= (u32
*) hash_buf
->digest
;
14077 salt_t
*salt
= hash_buf
->salt
;
14079 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14080 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14081 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14082 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14083 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14085 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14087 uint salt_len
= input_len
- 40 - 1;
14089 char *salt_buf
= input_buf
+ 40 + 1;
14091 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14093 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14095 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14097 salt
->salt_len
= salt_len
;
14099 return (PARSER_OK
);
14102 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14104 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14106 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14110 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14113 u32
*digest
= (u32
*) hash_buf
->digest
;
14115 salt_t
*salt
= hash_buf
->salt
;
14117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14121 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14122 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14123 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14124 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14126 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14128 uint salt_len
= input_len
- 64 - 1;
14130 char *salt_buf
= input_buf
+ 64 + 1;
14132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14136 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14138 salt
->salt_len
= salt_len
;
14140 return (PARSER_OK
);
14143 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14145 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14147 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14151 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14154 u64
*digest
= (u64
*) hash_buf
->digest
;
14156 salt_t
*salt
= hash_buf
->salt
;
14158 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14159 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14160 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14161 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14162 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14163 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14164 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14165 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14167 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14169 uint salt_len
= input_len
- 128 - 1;
14171 char *salt_buf
= input_buf
+ 128 + 1;
14173 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14175 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14177 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14179 salt
->salt_len
= salt_len
;
14181 return (PARSER_OK
);
14184 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14186 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14188 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14190 u32
*digest
= (u32
*) hash_buf
->digest
;
14192 salt_t
*salt
= hash_buf
->salt
;
14194 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14200 char *user_pos
= input_buf
+ 10 + 1;
14202 char *realm_pos
= strchr (user_pos
, '$');
14204 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14206 uint user_len
= realm_pos
- user_pos
;
14208 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14212 char *salt_pos
= strchr (realm_pos
, '$');
14214 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14216 uint realm_len
= salt_pos
- realm_pos
;
14218 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14222 char *data_pos
= strchr (salt_pos
, '$');
14224 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14226 uint salt_len
= data_pos
- salt_pos
;
14228 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14232 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14234 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14240 memcpy (krb5pa
->user
, user_pos
, user_len
);
14241 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14242 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14244 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14246 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14248 const char p0
= data_pos
[i
+ 0];
14249 const char p1
= data_pos
[i
+ 1];
14251 *timestamp_ptr
++ = hex_convert (p1
) << 0
14252 | hex_convert (p0
) << 4;
14255 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14257 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14259 const char p0
= data_pos
[i
+ 0];
14260 const char p1
= data_pos
[i
+ 1];
14262 *checksum_ptr
++ = hex_convert (p1
) << 0
14263 | hex_convert (p0
) << 4;
14267 * copy some data to generic buffers to make sorting happy
14270 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14271 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14272 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14273 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14274 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14275 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14276 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14277 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14278 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14280 salt
->salt_len
= 36;
14282 digest
[0] = krb5pa
->checksum
[0];
14283 digest
[1] = krb5pa
->checksum
[1];
14284 digest
[2] = krb5pa
->checksum
[2];
14285 digest
[3] = krb5pa
->checksum
[3];
14287 return (PARSER_OK
);
14290 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14292 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14294 u32
*digest
= (u32
*) hash_buf
->digest
;
14296 salt_t
*salt
= hash_buf
->salt
;
14302 char *salt_pos
= input_buf
;
14304 char *hash_pos
= strchr (salt_pos
, '$');
14306 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14308 uint salt_len
= hash_pos
- salt_pos
;
14310 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14314 uint hash_len
= input_len
- 1 - salt_len
;
14316 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14324 for (uint i
= 0; i
< salt_len
; i
++)
14326 if (salt_pos
[i
] == ' ') continue;
14331 // SAP user names cannot be longer than 12 characters
14332 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14334 // SAP user name cannot start with ! or ?
14335 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14347 salt
->salt_len
= salt_len
;
14349 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14350 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14354 digest
[0] = byte_swap_32 (digest
[0]);
14355 digest
[1] = byte_swap_32 (digest
[1]);
14357 return (PARSER_OK
);
14360 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14362 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14364 u32
*digest
= (u32
*) hash_buf
->digest
;
14366 salt_t
*salt
= hash_buf
->salt
;
14372 char *salt_pos
= input_buf
;
14374 char *hash_pos
= strchr (salt_pos
, '$');
14376 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14378 uint salt_len
= hash_pos
- salt_pos
;
14380 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14384 uint hash_len
= input_len
- 1 - salt_len
;
14386 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14394 for (uint i
= 0; i
< salt_len
; i
++)
14396 if (salt_pos
[i
] == ' ') continue;
14401 // SAP user names cannot be longer than 12 characters
14402 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14403 // so far nobody complained so we stay with this because it helps in optimization
14404 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14406 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14408 // SAP user name cannot start with ! or ?
14409 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14415 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14417 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14419 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14421 salt
->salt_len
= salt_len
;
14423 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14424 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14425 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14426 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14427 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14429 return (PARSER_OK
);
14432 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14434 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14436 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14438 u64
*digest
= (u64
*) hash_buf
->digest
;
14440 salt_t
*salt
= hash_buf
->salt
;
14442 char *iter_pos
= input_buf
+ 3;
14444 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14446 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14448 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14450 salt
->salt_iter
= salt_iter
;
14452 char *salt_pos
= iter_pos
+ 1;
14456 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14458 salt
->salt_len
= salt_len
;
14460 char *hash_pos
= salt_pos
+ salt_len
;
14462 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14466 char *tmp
= (char *) salt
->salt_buf_pc
;
14468 tmp
[0] = hash_pos
[42];
14472 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14473 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14474 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14475 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14481 return (PARSER_OK
);
14484 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14486 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14488 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14490 u32
*digest
= (u32
*) hash_buf
->digest
;
14492 salt_t
*salt
= hash_buf
->salt
;
14494 char *salt_buf
= input_buf
+ 6;
14496 uint salt_len
= 16;
14498 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14500 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14502 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14504 salt
->salt_len
= salt_len
;
14506 char *hash_pos
= input_buf
+ 6 + 16;
14508 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14509 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14510 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14511 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14512 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14513 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14514 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14515 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14517 return (PARSER_OK
);
14520 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14522 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14524 u32
*digest
= (u32
*) hash_buf
->digest
;
14526 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14527 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14531 return (PARSER_OK
);
14534 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14536 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14538 u32
*digest
= (u32
*) hash_buf
->digest
;
14540 salt_t
*salt
= hash_buf
->salt
;
14542 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14544 char *saltbuf_pos
= input_buf
;
14546 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14548 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14550 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14552 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14553 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14555 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14559 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14561 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14563 char *salt_ptr
= (char *) saltbuf_pos
;
14564 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14569 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14571 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14574 rakp_ptr
[j
] = 0x80;
14576 rakp
->salt_len
= j
;
14578 for (i
= 0; i
< 64; i
++)
14580 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14583 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14584 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14585 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14586 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14587 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14588 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14589 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14590 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14592 salt
->salt_len
= 32; // muss min. 32 haben
14594 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14595 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14596 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14597 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14598 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14600 return (PARSER_OK
);
14603 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14605 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14607 u32
*digest
= (u32
*) hash_buf
->digest
;
14609 salt_t
*salt
= hash_buf
->salt
;
14611 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14613 char *salt_pos
= input_buf
+ 1;
14615 memcpy (salt
->salt_buf
, salt_pos
, 8);
14617 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14618 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14620 salt
->salt_len
= 8;
14622 char *hash_pos
= salt_pos
+ 8;
14624 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14625 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14626 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14627 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14628 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14630 digest
[0] -= SHA1M_A
;
14631 digest
[1] -= SHA1M_B
;
14632 digest
[2] -= SHA1M_C
;
14633 digest
[3] -= SHA1M_D
;
14634 digest
[4] -= SHA1M_E
;
14636 return (PARSER_OK
);
14639 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14641 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14643 u32
*digest
= (u32
*) hash_buf
->digest
;
14645 salt_t
*salt
= hash_buf
->salt
;
14647 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14648 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14649 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14650 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14652 digest
[0] = byte_swap_32 (digest
[0]);
14653 digest
[1] = byte_swap_32 (digest
[1]);
14654 digest
[2] = byte_swap_32 (digest
[2]);
14655 digest
[3] = byte_swap_32 (digest
[3]);
14657 digest
[0] -= MD5M_A
;
14658 digest
[1] -= MD5M_B
;
14659 digest
[2] -= MD5M_C
;
14660 digest
[3] -= MD5M_D
;
14662 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14664 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14666 u32
*salt_buf
= salt
->salt_buf
;
14668 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14669 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14670 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14671 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14673 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14674 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14675 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14676 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14678 salt
->salt_len
= 16 + 1;
14680 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14682 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14684 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14686 return (PARSER_OK
);
14689 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14691 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14693 u32
*digest
= (u32
*) hash_buf
->digest
;
14695 salt_t
*salt
= hash_buf
->salt
;
14697 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14703 char *hashbuf_pos
= input_buf
;
14705 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14707 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14709 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14711 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14715 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14717 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14719 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14721 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14725 char *databuf_pos
= strchr (iteration_pos
, ':');
14727 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14729 const uint iteration_len
= databuf_pos
- iteration_pos
;
14731 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14732 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14734 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14736 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14737 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14743 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14744 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14745 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14746 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14747 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14748 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14749 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14750 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14754 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14756 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14758 const char p0
= saltbuf_pos
[i
+ 0];
14759 const char p1
= saltbuf_pos
[i
+ 1];
14761 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14762 | hex_convert (p0
) << 4;
14765 salt
->salt_buf
[4] = 0x01000000;
14766 salt
->salt_buf
[5] = 0x80;
14768 salt
->salt_len
= saltbuf_len
/ 2;
14772 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14776 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14778 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14780 const char p0
= databuf_pos
[i
+ 0];
14781 const char p1
= databuf_pos
[i
+ 1];
14783 *databuf_ptr
++ = hex_convert (p1
) << 0
14784 | hex_convert (p0
) << 4;
14787 *databuf_ptr
++ = 0x80;
14789 for (uint i
= 0; i
< 512; i
++)
14791 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14794 cloudkey
->data_len
= databuf_len
/ 2;
14796 return (PARSER_OK
);
14799 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14801 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14803 u32
*digest
= (u32
*) hash_buf
->digest
;
14805 salt_t
*salt
= hash_buf
->salt
;
14811 char *hashbuf_pos
= input_buf
;
14813 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14815 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14817 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14819 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14823 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14825 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14827 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14829 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14831 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14835 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14837 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14839 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14841 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14843 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14847 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14849 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14850 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14852 // ok, the plan for this algorithm is the following:
14853 // we have 2 salts here, the domain-name and a random salt
14854 // while both are used in the initial transformation,
14855 // only the random salt is used in the following iterations
14856 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14857 // and one that includes only the real salt (stored into salt_buf[]).
14858 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14860 u8 tmp_buf
[100] = { 0 };
14862 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14864 memcpy (digest
, tmp_buf
, 20);
14866 digest
[0] = byte_swap_32 (digest
[0]);
14867 digest
[1] = byte_swap_32 (digest
[1]);
14868 digest
[2] = byte_swap_32 (digest
[2]);
14869 digest
[3] = byte_swap_32 (digest
[3]);
14870 digest
[4] = byte_swap_32 (digest
[4]);
14874 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14876 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14878 char *len_ptr
= NULL
;
14880 for (uint i
= 0; i
< domainbuf_len
; i
++)
14882 if (salt_buf_pc_ptr
[i
] == '.')
14884 len_ptr
= &salt_buf_pc_ptr
[i
];
14894 salt
->salt_buf_pc
[7] = domainbuf_len
;
14898 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14900 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14902 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14904 salt
->salt_len
= salt_len
;
14908 salt
->salt_iter
= atoi (iteration_pos
);
14910 return (PARSER_OK
);
14913 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14915 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14917 u32
*digest
= (u32
*) hash_buf
->digest
;
14919 salt_t
*salt
= hash_buf
->salt
;
14921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14925 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14927 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14929 uint salt_len
= input_len
- 40 - 1;
14931 char *salt_buf
= input_buf
+ 40 + 1;
14933 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14935 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14939 salt
->salt_len
= salt_len
;
14941 return (PARSER_OK
);
14944 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14946 const u8 ascii_to_ebcdic
[] =
14948 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14949 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14950 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14951 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14952 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14953 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14954 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14955 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14956 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14957 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14958 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14959 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14960 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14961 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14962 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14963 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14966 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14968 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14970 u32
*digest
= (u32
*) hash_buf
->digest
;
14972 salt_t
*salt
= hash_buf
->salt
;
14974 char *salt_pos
= input_buf
+ 6 + 1;
14976 char *digest_pos
= strchr (salt_pos
, '*');
14978 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14980 uint salt_len
= digest_pos
- salt_pos
;
14982 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14984 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14986 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14990 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14991 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14993 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14995 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14997 salt
->salt_len
= salt_len
;
14999 for (uint i
= 0; i
< salt_len
; i
++)
15001 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15003 for (uint i
= salt_len
; i
< 8; i
++)
15005 salt_buf_pc_ptr
[i
] = 0x40;
15010 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15012 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15013 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15015 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15016 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15018 digest
[0] = byte_swap_32 (digest
[0]);
15019 digest
[1] = byte_swap_32 (digest
[1]);
15021 IP (digest
[0], digest
[1], tt
);
15023 digest
[0] = rotr32 (digest
[0], 29);
15024 digest
[1] = rotr32 (digest
[1], 29);
15028 return (PARSER_OK
);
15031 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15033 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15035 u32
*digest
= (u32
*) hash_buf
->digest
;
15037 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15038 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15039 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15040 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15042 digest
[0] = byte_swap_32 (digest
[0]);
15043 digest
[1] = byte_swap_32 (digest
[1]);
15044 digest
[2] = byte_swap_32 (digest
[2]);
15045 digest
[3] = byte_swap_32 (digest
[3]);
15047 return (PARSER_OK
);
15050 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15052 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15054 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15056 u32
*digest
= (u32
*) hash_buf
->digest
;
15058 salt_t
*salt
= hash_buf
->salt
;
15060 u8 tmp_buf
[120] = { 0 };
15062 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15064 tmp_buf
[3] += -4; // dont ask!
15066 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15068 salt
->salt_len
= 5;
15070 memcpy (digest
, tmp_buf
+ 5, 9);
15072 // yes, only 9 byte are needed to crack, but 10 to display
15074 salt
->salt_buf_pc
[7] = input_buf
[20];
15076 return (PARSER_OK
);
15079 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15081 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15083 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15085 u32
*digest
= (u32
*) hash_buf
->digest
;
15087 salt_t
*salt
= hash_buf
->salt
;
15089 u8 tmp_buf
[120] = { 0 };
15091 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15093 tmp_buf
[3] += -4; // dont ask!
15097 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15099 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)
15103 char tmp_iter_buf
[11] = { 0 };
15105 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15107 tmp_iter_buf
[10] = 0;
15109 salt
->salt_iter
= atoi (tmp_iter_buf
);
15111 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15113 return (PARSER_SALT_ITERATION
);
15116 salt
->salt_iter
--; // first round in init
15118 // 2 additional bytes for display only
15120 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15121 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15125 memcpy (digest
, tmp_buf
+ 28, 8);
15127 digest
[0] = byte_swap_32 (digest
[0]);
15128 digest
[1] = byte_swap_32 (digest
[1]);
15132 return (PARSER_OK
);
15135 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15137 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15139 u32
*digest
= (u32
*) hash_buf
->digest
;
15141 salt_t
*salt
= hash_buf
->salt
;
15143 char *salt_buf_pos
= input_buf
;
15145 char *hash_buf_pos
= salt_buf_pos
+ 6;
15147 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15148 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15149 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15150 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15151 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15152 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15153 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15154 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15156 digest
[0] -= SHA256M_A
;
15157 digest
[1] -= SHA256M_B
;
15158 digest
[2] -= SHA256M_C
;
15159 digest
[3] -= SHA256M_D
;
15160 digest
[4] -= SHA256M_E
;
15161 digest
[5] -= SHA256M_F
;
15162 digest
[6] -= SHA256M_G
;
15163 digest
[7] -= SHA256M_H
;
15165 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15167 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15171 salt
->salt_len
= salt_len
;
15173 return (PARSER_OK
);
15176 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15178 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15180 u32
*digest
= (u32
*) hash_buf
->digest
;
15182 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15184 salt_t
*salt
= hash_buf
->salt
;
15186 char *salt_buf
= input_buf
+ 6;
15188 char *digest_buf
= strchr (salt_buf
, '$');
15190 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15192 uint salt_len
= digest_buf
- salt_buf
;
15194 digest_buf
++; // skip the '$' symbol
15196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15198 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15202 salt
->salt_len
= salt_len
;
15204 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15205 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15206 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15207 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15209 digest
[0] = byte_swap_32 (digest
[0]);
15210 digest
[1] = byte_swap_32 (digest
[1]);
15211 digest
[2] = byte_swap_32 (digest
[2]);
15212 digest
[3] = byte_swap_32 (digest
[3]);
15214 digest
[0] -= MD5M_A
;
15215 digest
[1] -= MD5M_B
;
15216 digest
[2] -= MD5M_C
;
15217 digest
[3] -= MD5M_D
;
15219 return (PARSER_OK
);
15222 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15224 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15226 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15228 u32
*digest
= (u32
*) hash_buf
->digest
;
15230 salt_t
*salt
= hash_buf
->salt
;
15232 char *salt_buf
= input_buf
+ 3;
15234 char *digest_buf
= strchr (salt_buf
, '$');
15236 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15238 uint salt_len
= digest_buf
- salt_buf
;
15240 digest_buf
++; // skip the '$' symbol
15242 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15244 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15246 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15248 salt_buf_ptr
[salt_len
] = 0x2d;
15250 salt
->salt_len
= salt_len
+ 1;
15252 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15253 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15254 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15255 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15257 digest
[0] = byte_swap_32 (digest
[0]);
15258 digest
[1] = byte_swap_32 (digest
[1]);
15259 digest
[2] = byte_swap_32 (digest
[2]);
15260 digest
[3] = byte_swap_32 (digest
[3]);
15262 digest
[0] -= MD5M_A
;
15263 digest
[1] -= MD5M_B
;
15264 digest
[2] -= MD5M_C
;
15265 digest
[3] -= MD5M_D
;
15267 return (PARSER_OK
);
15270 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15272 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15274 u32
*digest
= (u32
*) hash_buf
->digest
;
15276 salt_t
*salt
= hash_buf
->salt
;
15278 u8 tmp_buf
[100] = { 0 };
15280 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15282 memcpy (digest
, tmp_buf
, 20);
15284 digest
[0] = byte_swap_32 (digest
[0]);
15285 digest
[1] = byte_swap_32 (digest
[1]);
15286 digest
[2] = byte_swap_32 (digest
[2]);
15287 digest
[3] = byte_swap_32 (digest
[3]);
15288 digest
[4] = byte_swap_32 (digest
[4]);
15290 digest
[0] -= SHA1M_A
;
15291 digest
[1] -= SHA1M_B
;
15292 digest
[2] -= SHA1M_C
;
15293 digest
[3] -= SHA1M_D
;
15294 digest
[4] -= SHA1M_E
;
15296 salt
->salt_buf
[0] = 0x80;
15298 salt
->salt_len
= 0;
15300 return (PARSER_OK
);
15303 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15305 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15307 u32
*digest
= (u32
*) hash_buf
->digest
;
15309 salt_t
*salt
= hash_buf
->salt
;
15311 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15312 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15313 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15314 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15316 digest
[0] = byte_swap_32 (digest
[0]);
15317 digest
[1] = byte_swap_32 (digest
[1]);
15318 digest
[2] = byte_swap_32 (digest
[2]);
15319 digest
[3] = byte_swap_32 (digest
[3]);
15321 digest
[0] -= MD5M_A
;
15322 digest
[1] -= MD5M_B
;
15323 digest
[2] -= MD5M_C
;
15324 digest
[3] -= MD5M_D
;
15326 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15328 uint salt_len
= input_len
- 32 - 1;
15330 char *salt_buf
= input_buf
+ 32 + 1;
15332 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15334 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15336 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15339 * add static "salt" part
15342 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15346 salt
->salt_len
= salt_len
;
15348 return (PARSER_OK
);
15351 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15353 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15355 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15357 u32
*digest
= (u32
*) hash_buf
->digest
;
15359 salt_t
*salt
= hash_buf
->salt
;
15361 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15367 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15369 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15371 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15373 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15375 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15379 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15381 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15383 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15385 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15389 char *keybuf_pos
= strchr (keylen_pos
, '$');
15391 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15393 uint keylen_len
= keybuf_pos
- keylen_pos
;
15395 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15399 char *databuf_pos
= strchr (keybuf_pos
, '$');
15401 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15403 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15405 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15409 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15411 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15417 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15418 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15419 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15420 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15422 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15423 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15424 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15425 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15427 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15428 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15429 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15430 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15432 salt
->salt_len
= 16;
15433 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15435 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15437 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15440 return (PARSER_OK
);
15443 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15445 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15447 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15449 u32
*digest
= (u32
*) hash_buf
->digest
;
15451 salt_t
*salt
= hash_buf
->salt
;
15457 // first is the N salt parameter
15459 char *N_pos
= input_buf
+ 6;
15461 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15465 salt
->scrypt_N
= atoi (N_pos
);
15469 char *r_pos
= strchr (N_pos
, ':');
15471 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15475 salt
->scrypt_r
= atoi (r_pos
);
15479 char *p_pos
= strchr (r_pos
, ':');
15481 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15485 salt
->scrypt_p
= atoi (p_pos
);
15489 char *saltbuf_pos
= strchr (p_pos
, ':');
15491 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15495 char *hash_pos
= strchr (saltbuf_pos
, ':');
15497 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15503 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15505 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15507 u8 tmp_buf
[33] = { 0 };
15509 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15511 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15513 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15515 salt
->salt_len
= tmp_len
;
15516 salt
->salt_iter
= 1;
15518 // digest - base64 decode
15520 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15522 tmp_len
= input_len
- (hash_pos
- input_buf
);
15524 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15526 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15528 memcpy (digest
, tmp_buf
, 32);
15530 return (PARSER_OK
);
15533 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15535 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15537 u32
*digest
= (u32
*) hash_buf
->digest
;
15539 salt_t
*salt
= hash_buf
->salt
;
15545 char decrypted
[76] = { 0 }; // iv + hash
15547 juniper_decrypt_hash (input_buf
, decrypted
);
15549 char *md5crypt_hash
= decrypted
+ 12;
15551 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15553 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15555 char *salt_pos
= md5crypt_hash
+ 3;
15557 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15559 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15561 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15565 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15567 return (PARSER_OK
);
15570 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15572 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15574 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15576 u32
*digest
= (u32
*) hash_buf
->digest
;
15578 salt_t
*salt
= hash_buf
->salt
;
15580 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15586 // first is *raw* salt
15588 char *salt_pos
= input_buf
+ 3;
15590 char *hash_pos
= strchr (salt_pos
, '$');
15592 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15594 uint salt_len
= hash_pos
- salt_pos
;
15596 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15600 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15602 memcpy (salt_buf_ptr
, salt_pos
, 14);
15604 salt_buf_ptr
[17] = 0x01;
15605 salt_buf_ptr
[18] = 0x80;
15607 // add some stuff to normal salt to make sorted happy
15609 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15610 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15611 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15612 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15614 salt
->salt_len
= salt_len
;
15615 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15617 // base64 decode hash
15619 u8 tmp_buf
[100] = { 0 };
15621 uint hash_len
= input_len
- 3 - salt_len
- 1;
15623 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15625 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15627 memcpy (digest
, tmp_buf
, 32);
15629 digest
[0] = byte_swap_32 (digest
[0]);
15630 digest
[1] = byte_swap_32 (digest
[1]);
15631 digest
[2] = byte_swap_32 (digest
[2]);
15632 digest
[3] = byte_swap_32 (digest
[3]);
15633 digest
[4] = byte_swap_32 (digest
[4]);
15634 digest
[5] = byte_swap_32 (digest
[5]);
15635 digest
[6] = byte_swap_32 (digest
[6]);
15636 digest
[7] = byte_swap_32 (digest
[7]);
15638 return (PARSER_OK
);
15641 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15643 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15645 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15647 u32
*digest
= (u32
*) hash_buf
->digest
;
15649 salt_t
*salt
= hash_buf
->salt
;
15655 // first is *raw* salt
15657 char *salt_pos
= input_buf
+ 3;
15659 char *hash_pos
= strchr (salt_pos
, '$');
15661 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15663 uint salt_len
= hash_pos
- salt_pos
;
15665 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15667 salt
->salt_len
= salt_len
;
15670 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15672 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15673 salt_buf_ptr
[salt_len
] = 0;
15675 // base64 decode hash
15677 u8 tmp_buf
[100] = { 0 };
15679 uint hash_len
= input_len
- 3 - salt_len
- 1;
15681 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15683 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15685 memcpy (digest
, tmp_buf
, 32);
15688 salt
->scrypt_N
= 16384;
15689 salt
->scrypt_r
= 1;
15690 salt
->scrypt_p
= 1;
15691 salt
->salt_iter
= 1;
15693 return (PARSER_OK
);
15696 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15698 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15700 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15702 u32
*digest
= (u32
*) hash_buf
->digest
;
15704 salt_t
*salt
= hash_buf
->salt
;
15706 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15712 char *version_pos
= input_buf
+ 8 + 1;
15714 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15716 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15718 u32 version_len
= verifierHashSize_pos
- version_pos
;
15720 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15722 verifierHashSize_pos
++;
15724 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15726 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15728 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15730 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15734 char *saltSize_pos
= strchr (keySize_pos
, '*');
15736 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15738 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15740 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15744 char *osalt_pos
= strchr (saltSize_pos
, '*');
15746 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15748 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15750 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15754 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15756 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15758 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15760 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15762 encryptedVerifier_pos
++;
15764 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15766 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15768 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15770 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15772 encryptedVerifierHash_pos
++;
15774 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;
15776 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15778 const uint version
= atoi (version_pos
);
15780 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15782 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15784 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15786 const uint keySize
= atoi (keySize_pos
);
15788 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15790 office2007
->keySize
= keySize
;
15792 const uint saltSize
= atoi (saltSize_pos
);
15794 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15800 salt
->salt_len
= 16;
15801 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15803 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15804 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15805 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15806 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15812 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15813 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15814 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15815 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15817 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15818 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15819 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15820 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15821 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15827 digest
[0] = office2007
->encryptedVerifierHash
[0];
15828 digest
[1] = office2007
->encryptedVerifierHash
[1];
15829 digest
[2] = office2007
->encryptedVerifierHash
[2];
15830 digest
[3] = office2007
->encryptedVerifierHash
[3];
15832 return (PARSER_OK
);
15835 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15837 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15839 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15841 u32
*digest
= (u32
*) hash_buf
->digest
;
15843 salt_t
*salt
= hash_buf
->salt
;
15845 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15851 char *version_pos
= input_buf
+ 8 + 1;
15853 char *spinCount_pos
= strchr (version_pos
, '*');
15855 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15857 u32 version_len
= spinCount_pos
- version_pos
;
15859 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15863 char *keySize_pos
= strchr (spinCount_pos
, '*');
15865 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15867 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15869 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15873 char *saltSize_pos
= strchr (keySize_pos
, '*');
15875 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15877 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15879 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15883 char *osalt_pos
= strchr (saltSize_pos
, '*');
15885 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15887 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15889 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15893 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15895 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15897 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15899 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15901 encryptedVerifier_pos
++;
15903 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15905 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15907 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15909 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15911 encryptedVerifierHash_pos
++;
15913 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;
15915 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15917 const uint version
= atoi (version_pos
);
15919 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15921 const uint spinCount
= atoi (spinCount_pos
);
15923 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15925 const uint keySize
= atoi (keySize_pos
);
15927 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15929 const uint saltSize
= atoi (saltSize_pos
);
15931 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15937 salt
->salt_len
= 16;
15938 salt
->salt_iter
= spinCount
;
15940 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15941 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15942 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15943 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15949 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15950 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15951 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15952 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15954 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15955 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15956 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15957 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15958 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15959 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15960 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15961 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15967 digest
[0] = office2010
->encryptedVerifierHash
[0];
15968 digest
[1] = office2010
->encryptedVerifierHash
[1];
15969 digest
[2] = office2010
->encryptedVerifierHash
[2];
15970 digest
[3] = office2010
->encryptedVerifierHash
[3];
15972 return (PARSER_OK
);
15975 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15977 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15979 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15981 u32
*digest
= (u32
*) hash_buf
->digest
;
15983 salt_t
*salt
= hash_buf
->salt
;
15985 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15991 char *version_pos
= input_buf
+ 8 + 1;
15993 char *spinCount_pos
= strchr (version_pos
, '*');
15995 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15997 u32 version_len
= spinCount_pos
- version_pos
;
15999 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16003 char *keySize_pos
= strchr (spinCount_pos
, '*');
16005 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16007 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16009 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16013 char *saltSize_pos
= strchr (keySize_pos
, '*');
16015 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16017 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16019 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16023 char *osalt_pos
= strchr (saltSize_pos
, '*');
16025 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16027 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16029 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16033 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16035 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16037 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16039 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16041 encryptedVerifier_pos
++;
16043 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16045 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16047 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16049 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16051 encryptedVerifierHash_pos
++;
16053 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;
16055 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16057 const uint version
= atoi (version_pos
);
16059 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16061 const uint spinCount
= atoi (spinCount_pos
);
16063 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16065 const uint keySize
= atoi (keySize_pos
);
16067 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16069 const uint saltSize
= atoi (saltSize_pos
);
16071 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16077 salt
->salt_len
= 16;
16078 salt
->salt_iter
= spinCount
;
16080 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16081 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16082 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16083 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16089 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16090 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16091 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16092 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16094 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16095 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16096 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16097 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16098 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16099 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16100 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16101 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16107 digest
[0] = office2013
->encryptedVerifierHash
[0];
16108 digest
[1] = office2013
->encryptedVerifierHash
[1];
16109 digest
[2] = office2013
->encryptedVerifierHash
[2];
16110 digest
[3] = office2013
->encryptedVerifierHash
[3];
16112 return (PARSER_OK
);
16115 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16117 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16119 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16121 u32
*digest
= (u32
*) hash_buf
->digest
;
16123 salt_t
*salt
= hash_buf
->salt
;
16125 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16131 char *version_pos
= input_buf
+ 11;
16133 char *osalt_pos
= strchr (version_pos
, '*');
16135 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16137 u32 version_len
= osalt_pos
- version_pos
;
16139 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16143 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16145 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16147 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16149 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16151 encryptedVerifier_pos
++;
16153 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16155 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16157 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16159 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16161 encryptedVerifierHash_pos
++;
16163 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16165 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16167 const uint version
= *version_pos
- 0x30;
16169 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16175 oldoffice01
->version
= version
;
16177 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16178 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16179 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16180 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16182 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16183 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16184 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16185 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16187 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16188 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16189 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16190 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16192 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16193 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16194 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16195 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16201 salt
->salt_len
= 16;
16203 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16204 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16205 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16206 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16208 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16209 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16210 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16211 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16213 // this is a workaround as office produces multiple documents with the same salt
16215 salt
->salt_len
+= 32;
16217 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16218 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16219 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16220 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16221 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16222 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16223 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16224 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16230 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16231 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16232 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16233 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16235 return (PARSER_OK
);
16238 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16240 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16243 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16245 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16247 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16249 u32
*digest
= (u32
*) hash_buf
->digest
;
16251 salt_t
*salt
= hash_buf
->salt
;
16253 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16259 char *version_pos
= input_buf
+ 11;
16261 char *osalt_pos
= strchr (version_pos
, '*');
16263 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16265 u32 version_len
= osalt_pos
- version_pos
;
16267 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16271 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16273 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16275 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16277 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16279 encryptedVerifier_pos
++;
16281 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16283 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16285 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16287 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16289 encryptedVerifierHash_pos
++;
16291 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16293 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16295 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16297 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16301 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16303 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16305 const uint version
= *version_pos
- 0x30;
16307 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16313 oldoffice01
->version
= version
;
16315 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16316 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16317 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16318 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16320 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16321 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16322 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16323 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16325 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16326 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16327 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16328 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16330 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16331 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16332 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16333 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16335 oldoffice01
->rc4key
[1] = 0;
16336 oldoffice01
->rc4key
[0] = 0;
16338 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16339 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16340 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16341 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16342 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16343 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16344 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16345 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16346 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16347 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16349 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16350 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16356 salt
->salt_len
= 16;
16358 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16359 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16360 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16361 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16363 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16364 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16365 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16366 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16368 // this is a workaround as office produces multiple documents with the same salt
16370 salt
->salt_len
+= 32;
16372 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16373 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16374 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16375 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16376 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16377 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16378 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16379 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16385 digest
[0] = oldoffice01
->rc4key
[0];
16386 digest
[1] = oldoffice01
->rc4key
[1];
16390 return (PARSER_OK
);
16393 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16395 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16397 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16399 u32
*digest
= (u32
*) hash_buf
->digest
;
16401 salt_t
*salt
= hash_buf
->salt
;
16403 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16409 char *version_pos
= input_buf
+ 11;
16411 char *osalt_pos
= strchr (version_pos
, '*');
16413 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16415 u32 version_len
= osalt_pos
- version_pos
;
16417 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16421 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16423 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16425 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16427 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16429 encryptedVerifier_pos
++;
16431 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16433 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16435 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16437 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16439 encryptedVerifierHash_pos
++;
16441 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16443 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16445 const uint version
= *version_pos
- 0x30;
16447 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16453 oldoffice34
->version
= version
;
16455 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16456 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16457 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16458 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16460 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16461 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16462 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16463 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16465 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16466 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16467 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16468 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16469 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16471 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16472 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16473 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16474 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16475 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16481 salt
->salt_len
= 16;
16483 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16484 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16485 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16486 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16488 // this is a workaround as office produces multiple documents with the same salt
16490 salt
->salt_len
+= 32;
16492 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16493 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16494 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16495 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16496 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16497 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16498 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16499 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16505 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16506 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16507 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16508 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16510 return (PARSER_OK
);
16513 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16515 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16517 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16520 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16522 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16524 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16526 u32
*digest
= (u32
*) hash_buf
->digest
;
16528 salt_t
*salt
= hash_buf
->salt
;
16530 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16536 char *version_pos
= input_buf
+ 11;
16538 char *osalt_pos
= strchr (version_pos
, '*');
16540 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16542 u32 version_len
= osalt_pos
- version_pos
;
16544 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16548 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16550 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16552 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16554 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16556 encryptedVerifier_pos
++;
16558 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16560 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16562 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16564 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16566 encryptedVerifierHash_pos
++;
16568 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16570 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16572 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16574 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16578 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16580 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16582 const uint version
= *version_pos
- 0x30;
16584 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16590 oldoffice34
->version
= version
;
16592 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16593 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16594 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16595 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16597 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16598 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16599 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16600 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16602 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16603 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16604 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16605 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16606 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16608 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16609 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16610 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16611 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16612 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16614 oldoffice34
->rc4key
[1] = 0;
16615 oldoffice34
->rc4key
[0] = 0;
16617 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16618 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16619 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16620 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16621 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16622 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16623 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16624 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16625 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16626 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16628 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16629 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16635 salt
->salt_len
= 16;
16637 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16638 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16639 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16640 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16642 // this is a workaround as office produces multiple documents with the same salt
16644 salt
->salt_len
+= 32;
16646 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16647 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16648 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16649 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16650 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16651 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16652 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16653 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16659 digest
[0] = oldoffice34
->rc4key
[0];
16660 digest
[1] = oldoffice34
->rc4key
[1];
16664 return (PARSER_OK
);
16667 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16669 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16671 u32
*digest
= (u32
*) hash_buf
->digest
;
16673 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16674 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16675 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16676 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16678 digest
[0] = byte_swap_32 (digest
[0]);
16679 digest
[1] = byte_swap_32 (digest
[1]);
16680 digest
[2] = byte_swap_32 (digest
[2]);
16681 digest
[3] = byte_swap_32 (digest
[3]);
16683 return (PARSER_OK
);
16686 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16688 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16690 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16692 u32
*digest
= (u32
*) hash_buf
->digest
;
16694 salt_t
*salt
= hash_buf
->salt
;
16696 char *signature_pos
= input_buf
;
16698 char *salt_pos
= strchr (signature_pos
, '$');
16700 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 u32 signature_len
= salt_pos
- signature_pos
;
16704 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16708 char *hash_pos
= strchr (salt_pos
, '$');
16710 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16712 u32 salt_len
= hash_pos
- salt_pos
;
16714 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16718 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16720 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16722 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16723 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16724 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16725 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16726 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16728 digest
[0] -= SHA1M_A
;
16729 digest
[1] -= SHA1M_B
;
16730 digest
[2] -= SHA1M_C
;
16731 digest
[3] -= SHA1M_D
;
16732 digest
[4] -= SHA1M_E
;
16734 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16736 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16738 salt
->salt_len
= salt_len
;
16740 return (PARSER_OK
);
16743 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16745 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16747 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16749 u32
*digest
= (u32
*) hash_buf
->digest
;
16751 salt_t
*salt
= hash_buf
->salt
;
16753 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16759 char *iter_pos
= input_buf
+ 14;
16761 const int iter
= atoi (iter_pos
);
16763 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16765 salt
->salt_iter
= iter
- 1;
16767 char *salt_pos
= strchr (iter_pos
, '$');
16769 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16773 char *hash_pos
= strchr (salt_pos
, '$');
16775 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16777 const uint salt_len
= hash_pos
- salt_pos
;
16781 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16783 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16785 salt
->salt_len
= salt_len
;
16787 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16788 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16790 // add some stuff to normal salt to make sorted happy
16792 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16793 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16794 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16795 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16796 salt
->salt_buf
[4] = salt
->salt_iter
;
16798 // base64 decode hash
16800 u8 tmp_buf
[100] = { 0 };
16802 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16804 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16806 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16808 memcpy (digest
, tmp_buf
, 32);
16810 digest
[0] = byte_swap_32 (digest
[0]);
16811 digest
[1] = byte_swap_32 (digest
[1]);
16812 digest
[2] = byte_swap_32 (digest
[2]);
16813 digest
[3] = byte_swap_32 (digest
[3]);
16814 digest
[4] = byte_swap_32 (digest
[4]);
16815 digest
[5] = byte_swap_32 (digest
[5]);
16816 digest
[6] = byte_swap_32 (digest
[6]);
16817 digest
[7] = byte_swap_32 (digest
[7]);
16819 return (PARSER_OK
);
16822 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16824 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16826 u32
*digest
= (u32
*) hash_buf
->digest
;
16828 salt_t
*salt
= hash_buf
->salt
;
16830 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16831 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16835 digest
[0] = byte_swap_32 (digest
[0]);
16836 digest
[1] = byte_swap_32 (digest
[1]);
16838 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16839 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16840 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16842 char iter_c
= input_buf
[17];
16843 char iter_d
= input_buf
[19];
16845 // atm only defaults, let's see if there's more request
16846 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16847 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16849 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16851 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16852 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16853 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16854 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16856 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16857 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16858 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16859 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16861 salt
->salt_len
= 16;
16863 return (PARSER_OK
);
16866 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16868 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16870 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16872 u32
*digest
= (u32
*) hash_buf
->digest
;
16874 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16876 salt_t
*salt
= hash_buf
->salt
;
16878 char *salt_pos
= input_buf
+ 10;
16880 char *hash_pos
= strchr (salt_pos
, '$');
16882 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16884 uint salt_len
= hash_pos
- salt_pos
;
16888 uint hash_len
= input_len
- 10 - salt_len
- 1;
16890 // base64 decode salt
16892 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16894 u8 tmp_buf
[100] = { 0 };
16896 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16898 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16900 tmp_buf
[salt_len
] = 0x80;
16902 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16904 salt
->salt_len
= salt_len
;
16906 // base64 decode hash
16908 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16910 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16912 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16914 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16916 uint user_len
= hash_len
- 32;
16918 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16920 user_len
--; // skip the trailing space
16922 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16923 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16924 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16925 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16927 digest
[0] = byte_swap_32 (digest
[0]);
16928 digest
[1] = byte_swap_32 (digest
[1]);
16929 digest
[2] = byte_swap_32 (digest
[2]);
16930 digest
[3] = byte_swap_32 (digest
[3]);
16932 // store username for host only (output hash if cracked)
16934 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16935 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16937 return (PARSER_OK
);
16940 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16942 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16944 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16946 u32
*digest
= (u32
*) hash_buf
->digest
;
16948 salt_t
*salt
= hash_buf
->salt
;
16950 char *iter_pos
= input_buf
+ 10;
16952 u32 iter
= atoi (iter_pos
);
16956 return (PARSER_SALT_ITERATION
);
16959 iter
--; // first iteration is special
16961 salt
->salt_iter
= iter
;
16963 char *base64_pos
= strchr (iter_pos
, '}');
16965 if (base64_pos
== NULL
)
16967 return (PARSER_SIGNATURE_UNMATCHED
);
16972 // base64 decode salt
16974 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16976 u8 tmp_buf
[100] = { 0 };
16978 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16980 if (decoded_len
< 24)
16982 return (PARSER_SALT_LENGTH
);
16987 uint salt_len
= decoded_len
- 20;
16989 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16990 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16992 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16994 salt
->salt_len
= salt_len
;
16998 u32
*digest_ptr
= (u32
*) tmp_buf
;
17000 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17001 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17002 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17003 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17004 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17006 return (PARSER_OK
);
17009 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17011 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17013 u32
*digest
= (u32
*) hash_buf
->digest
;
17015 salt_t
*salt
= hash_buf
->salt
;
17017 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17018 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17019 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17020 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17021 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17023 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17025 uint salt_len
= input_len
- 40 - 1;
17027 char *salt_buf
= input_buf
+ 40 + 1;
17029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17031 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17033 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17035 salt
->salt_len
= salt_len
;
17037 return (PARSER_OK
);
17040 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17042 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17044 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17046 u32
*digest
= (u32
*) hash_buf
->digest
;
17048 salt_t
*salt
= hash_buf
->salt
;
17050 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17056 char *V_pos
= input_buf
+ 5;
17058 char *R_pos
= strchr (V_pos
, '*');
17060 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17062 u32 V_len
= R_pos
- V_pos
;
17066 char *bits_pos
= strchr (R_pos
, '*');
17068 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17070 u32 R_len
= bits_pos
- R_pos
;
17074 char *P_pos
= strchr (bits_pos
, '*');
17076 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17078 u32 bits_len
= P_pos
- bits_pos
;
17082 char *enc_md_pos
= strchr (P_pos
, '*');
17084 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17086 u32 P_len
= enc_md_pos
- P_pos
;
17090 char *id_len_pos
= strchr (enc_md_pos
, '*');
17092 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17094 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17098 char *id_buf_pos
= strchr (id_len_pos
, '*');
17100 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17102 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17106 char *u_len_pos
= strchr (id_buf_pos
, '*');
17108 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17110 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17112 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17116 char *u_buf_pos
= strchr (u_len_pos
, '*');
17118 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17120 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17124 char *o_len_pos
= strchr (u_buf_pos
, '*');
17126 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17128 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17130 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17134 char *o_buf_pos
= strchr (o_len_pos
, '*');
17136 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17138 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17142 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;
17144 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17148 const int V
= atoi (V_pos
);
17149 const int R
= atoi (R_pos
);
17150 const int P
= atoi (P_pos
);
17152 if (V
!= 1) return (PARSER_SALT_VALUE
);
17153 if (R
!= 2) return (PARSER_SALT_VALUE
);
17155 const int enc_md
= atoi (enc_md_pos
);
17157 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17159 const int id_len
= atoi (id_len_pos
);
17160 const int u_len
= atoi (u_len_pos
);
17161 const int o_len
= atoi (o_len_pos
);
17163 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17164 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17165 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17167 const int bits
= atoi (bits_pos
);
17169 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17171 // copy data to esalt
17177 pdf
->enc_md
= enc_md
;
17179 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17180 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17181 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17182 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17183 pdf
->id_len
= id_len
;
17185 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17186 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17187 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17188 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17189 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17190 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17191 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17192 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17193 pdf
->u_len
= u_len
;
17195 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17196 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17197 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17198 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17199 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17200 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17201 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17202 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17203 pdf
->o_len
= o_len
;
17205 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17206 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17207 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17208 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17210 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17211 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17212 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17213 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17214 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17215 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17216 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17217 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17219 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17220 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17221 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17222 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17223 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17224 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17225 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17226 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17228 // we use ID for salt, maybe needs to change, we will see...
17230 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17231 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17232 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17233 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17234 salt
->salt_len
= pdf
->id_len
;
17236 digest
[0] = pdf
->u_buf
[0];
17237 digest
[1] = pdf
->u_buf
[1];
17238 digest
[2] = pdf
->u_buf
[2];
17239 digest
[3] = pdf
->u_buf
[3];
17241 return (PARSER_OK
);
17244 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17246 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17249 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17251 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17253 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17255 u32
*digest
= (u32
*) hash_buf
->digest
;
17257 salt_t
*salt
= hash_buf
->salt
;
17259 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17265 char *V_pos
= input_buf
+ 5;
17267 char *R_pos
= strchr (V_pos
, '*');
17269 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17271 u32 V_len
= R_pos
- V_pos
;
17275 char *bits_pos
= strchr (R_pos
, '*');
17277 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17279 u32 R_len
= bits_pos
- R_pos
;
17283 char *P_pos
= strchr (bits_pos
, '*');
17285 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17287 u32 bits_len
= P_pos
- bits_pos
;
17291 char *enc_md_pos
= strchr (P_pos
, '*');
17293 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 u32 P_len
= enc_md_pos
- P_pos
;
17299 char *id_len_pos
= strchr (enc_md_pos
, '*');
17301 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17303 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17307 char *id_buf_pos
= strchr (id_len_pos
, '*');
17309 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17315 char *u_len_pos
= strchr (id_buf_pos
, '*');
17317 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17319 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17321 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17325 char *u_buf_pos
= strchr (u_len_pos
, '*');
17327 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17329 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17333 char *o_len_pos
= strchr (u_buf_pos
, '*');
17335 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17337 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17339 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17343 char *o_buf_pos
= strchr (o_len_pos
, '*');
17345 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17347 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17351 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17353 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17355 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17357 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17361 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;
17363 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17367 const int V
= atoi (V_pos
);
17368 const int R
= atoi (R_pos
);
17369 const int P
= atoi (P_pos
);
17371 if (V
!= 1) return (PARSER_SALT_VALUE
);
17372 if (R
!= 2) return (PARSER_SALT_VALUE
);
17374 const int enc_md
= atoi (enc_md_pos
);
17376 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17378 const int id_len
= atoi (id_len_pos
);
17379 const int u_len
= atoi (u_len_pos
);
17380 const int o_len
= atoi (o_len_pos
);
17382 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17383 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17384 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17386 const int bits
= atoi (bits_pos
);
17388 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17390 // copy data to esalt
17396 pdf
->enc_md
= enc_md
;
17398 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17399 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17400 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17401 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17402 pdf
->id_len
= id_len
;
17404 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17405 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17406 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17407 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17408 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17409 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17410 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17411 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17412 pdf
->u_len
= u_len
;
17414 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17415 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17416 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17417 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17418 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17419 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17420 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17421 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17422 pdf
->o_len
= o_len
;
17424 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17425 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17426 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17427 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17429 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17430 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17431 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17432 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17433 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17434 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17435 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17436 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17438 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17439 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17440 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17441 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17442 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17443 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17444 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17445 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17447 pdf
->rc4key
[1] = 0;
17448 pdf
->rc4key
[0] = 0;
17450 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17451 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17452 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17453 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17454 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17455 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17456 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17457 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17458 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17459 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17461 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17462 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17464 // we use ID for salt, maybe needs to change, we will see...
17466 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17467 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17468 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17469 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17470 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17471 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17472 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17473 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17474 salt
->salt_len
= pdf
->id_len
+ 16;
17476 digest
[0] = pdf
->rc4key
[0];
17477 digest
[1] = pdf
->rc4key
[1];
17481 return (PARSER_OK
);
17484 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17486 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17488 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17490 u32
*digest
= (u32
*) hash_buf
->digest
;
17492 salt_t
*salt
= hash_buf
->salt
;
17494 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17500 char *V_pos
= input_buf
+ 5;
17502 char *R_pos
= strchr (V_pos
, '*');
17504 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17506 u32 V_len
= R_pos
- V_pos
;
17510 char *bits_pos
= strchr (R_pos
, '*');
17512 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17514 u32 R_len
= bits_pos
- R_pos
;
17518 char *P_pos
= strchr (bits_pos
, '*');
17520 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17522 u32 bits_len
= P_pos
- bits_pos
;
17526 char *enc_md_pos
= strchr (P_pos
, '*');
17528 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17530 u32 P_len
= enc_md_pos
- P_pos
;
17534 char *id_len_pos
= strchr (enc_md_pos
, '*');
17536 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17538 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17542 char *id_buf_pos
= strchr (id_len_pos
, '*');
17544 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17546 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17550 char *u_len_pos
= strchr (id_buf_pos
, '*');
17552 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17554 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17556 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17560 char *u_buf_pos
= strchr (u_len_pos
, '*');
17562 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17564 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17568 char *o_len_pos
= strchr (u_buf_pos
, '*');
17570 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17572 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17574 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17578 char *o_buf_pos
= strchr (o_len_pos
, '*');
17580 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17582 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17586 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;
17588 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17592 const int V
= atoi (V_pos
);
17593 const int R
= atoi (R_pos
);
17594 const int P
= atoi (P_pos
);
17598 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17599 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17601 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17603 const int id_len
= atoi (id_len_pos
);
17604 const int u_len
= atoi (u_len_pos
);
17605 const int o_len
= atoi (o_len_pos
);
17607 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17609 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17610 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17612 const int bits
= atoi (bits_pos
);
17614 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17620 enc_md
= atoi (enc_md_pos
);
17623 // copy data to esalt
17629 pdf
->enc_md
= enc_md
;
17631 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17632 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17633 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17634 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17638 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17639 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17640 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17641 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17644 pdf
->id_len
= id_len
;
17646 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17647 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17648 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17649 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17650 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17651 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17652 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17653 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17654 pdf
->u_len
= u_len
;
17656 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17657 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17658 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17659 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17660 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17661 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17662 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17663 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17664 pdf
->o_len
= o_len
;
17666 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17667 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17668 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17669 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17673 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17674 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17675 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17676 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17679 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17680 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17681 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17682 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17683 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17684 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17685 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17686 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17688 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17689 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17690 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17691 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17692 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17693 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17694 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17695 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17697 // precompute rc4 data for later use
17713 uint salt_pc_block
[32] = { 0 };
17715 char *salt_pc_ptr
= (char *) salt_pc_block
;
17717 memcpy (salt_pc_ptr
, padding
, 32);
17718 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17720 uint salt_pc_digest
[4] = { 0 };
17722 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17724 pdf
->rc4data
[0] = salt_pc_digest
[0];
17725 pdf
->rc4data
[1] = salt_pc_digest
[1];
17727 // we use ID for salt, maybe needs to change, we will see...
17729 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17730 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17731 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17732 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17733 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17734 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17735 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17736 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17737 salt
->salt_len
= pdf
->id_len
+ 16;
17739 salt
->salt_iter
= ROUNDS_PDF14
;
17741 digest
[0] = pdf
->u_buf
[0];
17742 digest
[1] = pdf
->u_buf
[1];
17746 return (PARSER_OK
);
17749 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17751 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17753 if (ret
!= PARSER_OK
)
17758 u32
*digest
= (u32
*) hash_buf
->digest
;
17760 salt_t
*salt
= hash_buf
->salt
;
17762 digest
[0] -= SHA256M_A
;
17763 digest
[1] -= SHA256M_B
;
17764 digest
[2] -= SHA256M_C
;
17765 digest
[3] -= SHA256M_D
;
17766 digest
[4] -= SHA256M_E
;
17767 digest
[5] -= SHA256M_F
;
17768 digest
[6] -= SHA256M_G
;
17769 digest
[7] -= SHA256M_H
;
17771 salt
->salt_buf
[2] = 0x80;
17773 return (PARSER_OK
);
17776 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17778 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17780 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17782 u32
*digest
= (u32
*) hash_buf
->digest
;
17784 salt_t
*salt
= hash_buf
->salt
;
17786 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17792 char *V_pos
= input_buf
+ 5;
17794 char *R_pos
= strchr (V_pos
, '*');
17796 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17798 u32 V_len
= R_pos
- V_pos
;
17802 char *bits_pos
= strchr (R_pos
, '*');
17804 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17806 u32 R_len
= bits_pos
- R_pos
;
17810 char *P_pos
= strchr (bits_pos
, '*');
17812 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17814 u32 bits_len
= P_pos
- bits_pos
;
17818 char *enc_md_pos
= strchr (P_pos
, '*');
17820 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17822 u32 P_len
= enc_md_pos
- P_pos
;
17826 char *id_len_pos
= strchr (enc_md_pos
, '*');
17828 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17830 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17834 char *id_buf_pos
= strchr (id_len_pos
, '*');
17836 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17838 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17842 char *u_len_pos
= strchr (id_buf_pos
, '*');
17844 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17846 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17850 char *u_buf_pos
= strchr (u_len_pos
, '*');
17852 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17854 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17858 char *o_len_pos
= strchr (u_buf_pos
, '*');
17860 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17862 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17866 char *o_buf_pos
= strchr (o_len_pos
, '*');
17868 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17870 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17874 char *last
= strchr (o_buf_pos
, '*');
17876 if (last
== NULL
) last
= input_buf
+ input_len
;
17878 u32 o_buf_len
= last
- o_buf_pos
;
17882 const int V
= atoi (V_pos
);
17883 const int R
= atoi (R_pos
);
17887 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17888 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17890 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17892 const int bits
= atoi (bits_pos
);
17894 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17896 int enc_md
= atoi (enc_md_pos
);
17898 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17900 const uint id_len
= atoi (id_len_pos
);
17901 const uint u_len
= atoi (u_len_pos
);
17902 const uint o_len
= atoi (o_len_pos
);
17904 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17905 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17906 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17907 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17908 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17909 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17910 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17911 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17913 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17914 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17915 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17917 // copy data to esalt
17919 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17921 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17923 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17926 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17927 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17929 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17930 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17932 salt
->salt_len
= 8;
17933 salt
->salt_iter
= ROUNDS_PDF17L8
;
17935 digest
[0] = pdf
->u_buf
[0];
17936 digest
[1] = pdf
->u_buf
[1];
17937 digest
[2] = pdf
->u_buf
[2];
17938 digest
[3] = pdf
->u_buf
[3];
17939 digest
[4] = pdf
->u_buf
[4];
17940 digest
[5] = pdf
->u_buf
[5];
17941 digest
[6] = pdf
->u_buf
[6];
17942 digest
[7] = pdf
->u_buf
[7];
17944 return (PARSER_OK
);
17947 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17949 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17951 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17953 u32
*digest
= (u32
*) hash_buf
->digest
;
17955 salt_t
*salt
= hash_buf
->salt
;
17957 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17965 char *iter_pos
= input_buf
+ 7;
17967 u32 iter
= atoi (iter_pos
);
17969 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17970 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17972 // first is *raw* salt
17974 char *salt_pos
= strchr (iter_pos
, ':');
17976 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17980 char *hash_pos
= strchr (salt_pos
, ':');
17982 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17984 u32 salt_len
= hash_pos
- salt_pos
;
17986 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17990 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17992 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17996 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17998 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18000 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18002 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18003 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18005 salt
->salt_len
= salt_len
;
18006 salt
->salt_iter
= iter
- 1;
18010 u8 tmp_buf
[100] = { 0 };
18012 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18014 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18016 memcpy (digest
, tmp_buf
, 16);
18018 digest
[0] = byte_swap_32 (digest
[0]);
18019 digest
[1] = byte_swap_32 (digest
[1]);
18020 digest
[2] = byte_swap_32 (digest
[2]);
18021 digest
[3] = byte_swap_32 (digest
[3]);
18023 // add some stuff to normal salt to make sorted happy
18025 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18026 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18027 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18028 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18029 salt
->salt_buf
[4] = salt
->salt_iter
;
18031 return (PARSER_OK
);
18034 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18036 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18038 u32
*digest
= (u32
*) hash_buf
->digest
;
18040 salt_t
*salt
= hash_buf
->salt
;
18042 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18043 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18044 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18045 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18047 digest
[0] = byte_swap_32 (digest
[0]);
18048 digest
[1] = byte_swap_32 (digest
[1]);
18049 digest
[2] = byte_swap_32 (digest
[2]);
18050 digest
[3] = byte_swap_32 (digest
[3]);
18052 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18054 uint salt_len
= input_len
- 32 - 1;
18056 char *salt_buf
= input_buf
+ 32 + 1;
18058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18064 salt
->salt_len
= salt_len
;
18066 return (PARSER_OK
);
18069 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18071 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18073 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18075 u32
*digest
= (u32
*) hash_buf
->digest
;
18077 salt_t
*salt
= hash_buf
->salt
;
18079 char *user_pos
= input_buf
+ 10;
18081 char *salt_pos
= strchr (user_pos
, '*');
18083 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18087 char *hash_pos
= strchr (salt_pos
, '*');
18091 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18093 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18095 uint user_len
= salt_pos
- user_pos
- 1;
18097 uint salt_len
= hash_pos
- salt_pos
- 1;
18099 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18105 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18106 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18107 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18108 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18110 digest
[0] = byte_swap_32 (digest
[0]);
18111 digest
[1] = byte_swap_32 (digest
[1]);
18112 digest
[2] = byte_swap_32 (digest
[2]);
18113 digest
[3] = byte_swap_32 (digest
[3]);
18115 digest
[0] -= MD5M_A
;
18116 digest
[1] -= MD5M_B
;
18117 digest
[2] -= MD5M_C
;
18118 digest
[3] -= MD5M_D
;
18124 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18126 // first 4 bytes are the "challenge"
18128 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18129 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18130 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18131 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18133 // append the user name
18135 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18137 salt
->salt_len
= 4 + user_len
;
18139 return (PARSER_OK
);
18142 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18144 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18146 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18148 u32
*digest
= (u32
*) hash_buf
->digest
;
18150 salt_t
*salt
= hash_buf
->salt
;
18152 char *salt_pos
= input_buf
+ 9;
18154 char *hash_pos
= strchr (salt_pos
, '*');
18156 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18160 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18162 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18164 uint salt_len
= hash_pos
- salt_pos
- 1;
18166 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18172 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18173 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18174 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18175 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18176 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18182 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18184 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18186 salt
->salt_len
= salt_len
;
18188 return (PARSER_OK
);
18191 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18193 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18195 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18197 u32
*digest
= (u32
*) hash_buf
->digest
;
18199 salt_t
*salt
= hash_buf
->salt
;
18201 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18207 char *cry_master_len_pos
= input_buf
+ 9;
18209 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18211 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18213 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18215 cry_master_buf_pos
++;
18217 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18219 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18221 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18223 cry_salt_len_pos
++;
18225 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18227 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18229 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18231 cry_salt_buf_pos
++;
18233 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18235 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18237 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18241 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18243 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18245 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18249 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18251 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18253 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18257 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18259 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18261 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18263 public_key_len_pos
++;
18265 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18267 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18269 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18271 public_key_buf_pos
++;
18273 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;
18275 const uint cry_master_len
= atoi (cry_master_len_pos
);
18276 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18277 const uint ckey_len
= atoi (ckey_len_pos
);
18278 const uint public_key_len
= atoi (public_key_len_pos
);
18280 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18281 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18282 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18283 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18285 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18287 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18289 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18292 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18294 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18296 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18299 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18301 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18303 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18306 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18307 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18308 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18311 * store digest (should be unique enought, hopefully)
18314 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18315 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18316 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18317 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18323 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18325 const uint cry_rounds
= atoi (cry_rounds_pos
);
18327 salt
->salt_iter
= cry_rounds
- 1;
18329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18331 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18333 salt
->salt_len
= salt_len
;
18335 return (PARSER_OK
);
18338 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18340 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18342 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18344 u32
*digest
= (u32
*) hash_buf
->digest
;
18346 salt_t
*salt
= hash_buf
->salt
;
18348 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18350 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18352 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18354 memcpy (temp_input_buf
, input_buf
, input_len
);
18358 char *URI_server_pos
= temp_input_buf
+ 6;
18360 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18362 if (URI_client_pos
== NULL
)
18364 myfree (temp_input_buf
);
18366 return (PARSER_SEPARATOR_UNMATCHED
);
18369 URI_client_pos
[0] = 0;
18372 uint URI_server_len
= strlen (URI_server_pos
);
18374 if (URI_server_len
> 512)
18376 myfree (temp_input_buf
);
18378 return (PARSER_SALT_LENGTH
);
18383 char *user_pos
= strchr (URI_client_pos
, '*');
18385 if (user_pos
== NULL
)
18387 myfree (temp_input_buf
);
18389 return (PARSER_SEPARATOR_UNMATCHED
);
18395 uint URI_client_len
= strlen (URI_client_pos
);
18397 if (URI_client_len
> 512)
18399 myfree (temp_input_buf
);
18401 return (PARSER_SALT_LENGTH
);
18406 char *realm_pos
= strchr (user_pos
, '*');
18408 if (realm_pos
== NULL
)
18410 myfree (temp_input_buf
);
18412 return (PARSER_SEPARATOR_UNMATCHED
);
18418 uint user_len
= strlen (user_pos
);
18420 if (user_len
> 116)
18422 myfree (temp_input_buf
);
18424 return (PARSER_SALT_LENGTH
);
18429 char *method_pos
= strchr (realm_pos
, '*');
18431 if (method_pos
== NULL
)
18433 myfree (temp_input_buf
);
18435 return (PARSER_SEPARATOR_UNMATCHED
);
18441 uint realm_len
= strlen (realm_pos
);
18443 if (realm_len
> 116)
18445 myfree (temp_input_buf
);
18447 return (PARSER_SALT_LENGTH
);
18452 char *URI_prefix_pos
= strchr (method_pos
, '*');
18454 if (URI_prefix_pos
== NULL
)
18456 myfree (temp_input_buf
);
18458 return (PARSER_SEPARATOR_UNMATCHED
);
18461 URI_prefix_pos
[0] = 0;
18464 uint method_len
= strlen (method_pos
);
18466 if (method_len
> 246)
18468 myfree (temp_input_buf
);
18470 return (PARSER_SALT_LENGTH
);
18475 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18477 if (URI_resource_pos
== NULL
)
18479 myfree (temp_input_buf
);
18481 return (PARSER_SEPARATOR_UNMATCHED
);
18484 URI_resource_pos
[0] = 0;
18485 URI_resource_pos
++;
18487 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18489 if (URI_prefix_len
> 245)
18491 myfree (temp_input_buf
);
18493 return (PARSER_SALT_LENGTH
);
18498 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18500 if (URI_suffix_pos
== NULL
)
18502 myfree (temp_input_buf
);
18504 return (PARSER_SEPARATOR_UNMATCHED
);
18507 URI_suffix_pos
[0] = 0;
18510 uint URI_resource_len
= strlen (URI_resource_pos
);
18512 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18514 myfree (temp_input_buf
);
18516 return (PARSER_SALT_LENGTH
);
18521 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18523 if (nonce_pos
== NULL
)
18525 myfree (temp_input_buf
);
18527 return (PARSER_SEPARATOR_UNMATCHED
);
18533 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18535 if (URI_suffix_len
> 245)
18537 myfree (temp_input_buf
);
18539 return (PARSER_SALT_LENGTH
);
18544 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18546 if (nonce_client_pos
== NULL
)
18548 myfree (temp_input_buf
);
18550 return (PARSER_SEPARATOR_UNMATCHED
);
18553 nonce_client_pos
[0] = 0;
18554 nonce_client_pos
++;
18556 uint nonce_len
= strlen (nonce_pos
);
18558 if (nonce_len
< 1 || nonce_len
> 50)
18560 myfree (temp_input_buf
);
18562 return (PARSER_SALT_LENGTH
);
18567 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18569 if (nonce_count_pos
== NULL
)
18571 myfree (temp_input_buf
);
18573 return (PARSER_SEPARATOR_UNMATCHED
);
18576 nonce_count_pos
[0] = 0;
18579 uint nonce_client_len
= strlen (nonce_client_pos
);
18581 if (nonce_client_len
> 50)
18583 myfree (temp_input_buf
);
18585 return (PARSER_SALT_LENGTH
);
18590 char *qop_pos
= strchr (nonce_count_pos
, '*');
18592 if (qop_pos
== NULL
)
18594 myfree (temp_input_buf
);
18596 return (PARSER_SEPARATOR_UNMATCHED
);
18602 uint nonce_count_len
= strlen (nonce_count_pos
);
18604 if (nonce_count_len
> 50)
18606 myfree (temp_input_buf
);
18608 return (PARSER_SALT_LENGTH
);
18613 char *directive_pos
= strchr (qop_pos
, '*');
18615 if (directive_pos
== NULL
)
18617 myfree (temp_input_buf
);
18619 return (PARSER_SEPARATOR_UNMATCHED
);
18622 directive_pos
[0] = 0;
18625 uint qop_len
= strlen (qop_pos
);
18629 myfree (temp_input_buf
);
18631 return (PARSER_SALT_LENGTH
);
18636 char *digest_pos
= strchr (directive_pos
, '*');
18638 if (digest_pos
== NULL
)
18640 myfree (temp_input_buf
);
18642 return (PARSER_SEPARATOR_UNMATCHED
);
18648 uint directive_len
= strlen (directive_pos
);
18650 if (directive_len
!= 3)
18652 myfree (temp_input_buf
);
18654 return (PARSER_SALT_LENGTH
);
18657 if (memcmp (directive_pos
, "MD5", 3))
18659 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18661 myfree (temp_input_buf
);
18663 return (PARSER_SIP_AUTH_DIRECTIVE
);
18667 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18672 uint md5_max_len
= 4 * 64;
18674 uint md5_remaining_len
= md5_max_len
;
18676 uint tmp_md5_buf
[64] = { 0 };
18678 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18680 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18682 md5_len
+= method_len
+ 1;
18683 tmp_md5_ptr
+= method_len
+ 1;
18685 if (URI_prefix_len
> 0)
18687 md5_remaining_len
= md5_max_len
- md5_len
;
18689 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18691 md5_len
+= URI_prefix_len
+ 1;
18692 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18695 md5_remaining_len
= md5_max_len
- md5_len
;
18697 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18699 md5_len
+= URI_resource_len
;
18700 tmp_md5_ptr
+= URI_resource_len
;
18702 if (URI_suffix_len
> 0)
18704 md5_remaining_len
= md5_max_len
- md5_len
;
18706 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18708 md5_len
+= 1 + URI_suffix_len
;
18711 uint tmp_digest
[4] = { 0 };
18713 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18715 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18716 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18717 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18718 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18724 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18726 uint esalt_len
= 0;
18728 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18730 // there are 2 possibilities for the esalt:
18732 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18734 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18736 if (esalt_len
> max_esalt_len
)
18738 myfree (temp_input_buf
);
18740 return (PARSER_SALT_LENGTH
);
18743 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18755 esalt_len
= 1 + nonce_len
+ 1 + 32;
18757 if (esalt_len
> max_esalt_len
)
18759 myfree (temp_input_buf
);
18761 return (PARSER_SALT_LENGTH
);
18764 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18772 // add 0x80 to esalt
18774 esalt_buf_ptr
[esalt_len
] = 0x80;
18776 sip
->esalt_len
= esalt_len
;
18782 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18784 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18786 uint max_salt_len
= 119;
18788 if (salt_len
> max_salt_len
)
18790 myfree (temp_input_buf
);
18792 return (PARSER_SALT_LENGTH
);
18795 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18797 sip
->salt_len
= salt_len
;
18800 * fake salt (for sorting)
18803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18807 uint fake_salt_len
= salt_len
;
18809 if (fake_salt_len
> max_salt_len
)
18811 fake_salt_len
= max_salt_len
;
18814 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18816 salt
->salt_len
= fake_salt_len
;
18822 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18823 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18824 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18825 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18827 digest
[0] = byte_swap_32 (digest
[0]);
18828 digest
[1] = byte_swap_32 (digest
[1]);
18829 digest
[2] = byte_swap_32 (digest
[2]);
18830 digest
[3] = byte_swap_32 (digest
[3]);
18832 myfree (temp_input_buf
);
18834 return (PARSER_OK
);
18837 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18839 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18841 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18843 u32
*digest
= (u32
*) hash_buf
->digest
;
18845 salt_t
*salt
= hash_buf
->salt
;
18849 char *digest_pos
= input_buf
;
18851 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18858 char *salt_buf
= input_buf
+ 8 + 1;
18862 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18864 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18866 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18868 salt
->salt_len
= salt_len
;
18870 return (PARSER_OK
);
18873 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18875 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18877 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18879 u32
*digest
= (u32
*) hash_buf
->digest
;
18881 salt_t
*salt
= hash_buf
->salt
;
18883 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18889 char *p_buf_pos
= input_buf
+ 4;
18891 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18893 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18895 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18897 NumCyclesPower_pos
++;
18899 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18901 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18903 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18907 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18909 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18911 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18915 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18917 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18919 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18923 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18925 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18927 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18931 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18933 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18935 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18939 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18941 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18943 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18947 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18949 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18951 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18955 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18957 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18959 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18963 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;
18965 const uint iter
= atoi (NumCyclesPower_pos
);
18966 const uint crc
= atoi (crc_buf_pos
);
18967 const uint p_buf
= atoi (p_buf_pos
);
18968 const uint salt_len
= atoi (salt_len_pos
);
18969 const uint iv_len
= atoi (iv_len_pos
);
18970 const uint unpack_size
= atoi (unpack_size_pos
);
18971 const uint data_len
= atoi (data_len_pos
);
18977 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18978 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18980 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18982 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18984 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18990 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18991 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18992 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18993 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18995 seven_zip
->iv_len
= iv_len
;
18997 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18999 seven_zip
->salt_len
= 0;
19001 seven_zip
->crc
= crc
;
19003 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19005 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19007 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19010 seven_zip
->data_len
= data_len
;
19012 seven_zip
->unpack_size
= unpack_size
;
19016 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19017 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19018 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19019 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19021 salt
->salt_len
= 16;
19023 salt
->salt_sign
[0] = iter
;
19025 salt
->salt_iter
= 1 << iter
;
19036 return (PARSER_OK
);
19039 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19041 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19043 u32
*digest
= (u32
*) hash_buf
->digest
;
19045 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19046 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19047 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19048 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19049 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19050 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19051 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19052 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19054 digest
[0] = byte_swap_32 (digest
[0]);
19055 digest
[1] = byte_swap_32 (digest
[1]);
19056 digest
[2] = byte_swap_32 (digest
[2]);
19057 digest
[3] = byte_swap_32 (digest
[3]);
19058 digest
[4] = byte_swap_32 (digest
[4]);
19059 digest
[5] = byte_swap_32 (digest
[5]);
19060 digest
[6] = byte_swap_32 (digest
[6]);
19061 digest
[7] = byte_swap_32 (digest
[7]);
19063 return (PARSER_OK
);
19066 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19068 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19070 u32
*digest
= (u32
*) hash_buf
->digest
;
19072 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19073 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19074 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19075 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19076 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19077 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19078 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19079 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19080 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19081 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19082 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19083 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19084 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19085 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19086 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19087 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19089 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19090 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19091 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19092 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19093 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19094 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19095 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19096 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19097 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19098 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19099 digest
[10] = byte_swap_32 (digest
[10]);
19100 digest
[11] = byte_swap_32 (digest
[11]);
19101 digest
[12] = byte_swap_32 (digest
[12]);
19102 digest
[13] = byte_swap_32 (digest
[13]);
19103 digest
[14] = byte_swap_32 (digest
[14]);
19104 digest
[15] = byte_swap_32 (digest
[15]);
19106 return (PARSER_OK
);
19109 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19111 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19113 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19115 u32
*digest
= (u32
*) hash_buf
->digest
;
19117 salt_t
*salt
= hash_buf
->salt
;
19119 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19127 char *iter_pos
= input_buf
+ 4;
19129 u32 iter
= atoi (iter_pos
);
19131 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19132 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19134 // first is *raw* salt
19136 char *salt_pos
= strchr (iter_pos
, ':');
19138 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19142 char *hash_pos
= strchr (salt_pos
, ':');
19144 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19146 u32 salt_len
= hash_pos
- salt_pos
;
19148 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19152 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19154 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19158 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19164 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19165 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19167 salt
->salt_len
= salt_len
;
19168 salt
->salt_iter
= iter
- 1;
19172 u8 tmp_buf
[100] = { 0 };
19174 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19176 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19178 memcpy (digest
, tmp_buf
, 16);
19180 // add some stuff to normal salt to make sorted happy
19182 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19183 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19184 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19185 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19186 salt
->salt_buf
[4] = salt
->salt_iter
;
19188 return (PARSER_OK
);
19191 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19193 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19195 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19197 u32
*digest
= (u32
*) hash_buf
->digest
;
19199 salt_t
*salt
= hash_buf
->salt
;
19201 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19209 char *iter_pos
= input_buf
+ 5;
19211 u32 iter
= atoi (iter_pos
);
19213 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19214 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19216 // first is *raw* salt
19218 char *salt_pos
= strchr (iter_pos
, ':');
19220 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19224 char *hash_pos
= strchr (salt_pos
, ':');
19226 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19228 u32 salt_len
= hash_pos
- salt_pos
;
19230 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19234 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19236 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19240 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19246 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19247 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19249 salt
->salt_len
= salt_len
;
19250 salt
->salt_iter
= iter
- 1;
19254 u8 tmp_buf
[100] = { 0 };
19256 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19258 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19260 memcpy (digest
, tmp_buf
, 16);
19262 digest
[0] = byte_swap_32 (digest
[0]);
19263 digest
[1] = byte_swap_32 (digest
[1]);
19264 digest
[2] = byte_swap_32 (digest
[2]);
19265 digest
[3] = byte_swap_32 (digest
[3]);
19267 // add some stuff to normal salt to make sorted happy
19269 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19270 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19271 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19272 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19273 salt
->salt_buf
[4] = salt
->salt_iter
;
19275 return (PARSER_OK
);
19278 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19280 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19282 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19284 u64
*digest
= (u64
*) hash_buf
->digest
;
19286 salt_t
*salt
= hash_buf
->salt
;
19288 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19296 char *iter_pos
= input_buf
+ 7;
19298 u32 iter
= atoi (iter_pos
);
19300 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19301 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19303 // first is *raw* salt
19305 char *salt_pos
= strchr (iter_pos
, ':');
19307 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19311 char *hash_pos
= strchr (salt_pos
, ':');
19313 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19315 u32 salt_len
= hash_pos
- salt_pos
;
19317 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19321 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19323 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19327 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19333 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19334 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19336 salt
->salt_len
= salt_len
;
19337 salt
->salt_iter
= iter
- 1;
19341 u8 tmp_buf
[100] = { 0 };
19343 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19345 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19347 memcpy (digest
, tmp_buf
, 64);
19349 digest
[0] = byte_swap_64 (digest
[0]);
19350 digest
[1] = byte_swap_64 (digest
[1]);
19351 digest
[2] = byte_swap_64 (digest
[2]);
19352 digest
[3] = byte_swap_64 (digest
[3]);
19353 digest
[4] = byte_swap_64 (digest
[4]);
19354 digest
[5] = byte_swap_64 (digest
[5]);
19355 digest
[6] = byte_swap_64 (digest
[6]);
19356 digest
[7] = byte_swap_64 (digest
[7]);
19358 // add some stuff to normal salt to make sorted happy
19360 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19361 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19362 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19363 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19364 salt
->salt_buf
[4] = salt
->salt_iter
;
19366 return (PARSER_OK
);
19369 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19371 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19373 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19375 uint
*digest
= (uint
*) hash_buf
->digest
;
19377 salt_t
*salt
= hash_buf
->salt
;
19383 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19385 char *hash_pos
= strchr (salt_pos
, '$');
19387 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19389 u32 salt_len
= hash_pos
- salt_pos
;
19391 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19395 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19397 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19401 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19402 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19420 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19421 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19423 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19424 salt
->salt_len
= 8;
19426 return (PARSER_OK
);
19429 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19431 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19433 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19435 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19437 if (c19
& 3) return (PARSER_HASH_VALUE
);
19439 salt_t
*salt
= hash_buf
->salt
;
19441 u32
*digest
= (u32
*) hash_buf
->digest
;
19445 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19446 | itoa64_to_int (input_buf
[2]) << 6
19447 | itoa64_to_int (input_buf
[3]) << 12
19448 | itoa64_to_int (input_buf
[4]) << 18;
19452 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19453 | itoa64_to_int (input_buf
[6]) << 6
19454 | itoa64_to_int (input_buf
[7]) << 12
19455 | itoa64_to_int (input_buf
[8]) << 18;
19457 salt
->salt_len
= 4;
19459 u8 tmp_buf
[100] = { 0 };
19461 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19463 memcpy (digest
, tmp_buf
, 8);
19467 IP (digest
[0], digest
[1], tt
);
19469 digest
[0] = rotr32 (digest
[0], 31);
19470 digest
[1] = rotr32 (digest
[1], 31);
19474 return (PARSER_OK
);
19477 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19479 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19481 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19483 u32
*digest
= (u32
*) hash_buf
->digest
;
19485 salt_t
*salt
= hash_buf
->salt
;
19491 char *type_pos
= input_buf
+ 6 + 1;
19493 char *salt_pos
= strchr (type_pos
, '*');
19495 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19497 u32 type_len
= salt_pos
- type_pos
;
19499 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19503 char *crypted_pos
= strchr (salt_pos
, '*');
19505 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19507 u32 salt_len
= crypted_pos
- salt_pos
;
19509 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19513 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19515 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19521 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19522 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19524 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19525 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19527 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19528 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19529 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19530 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19532 salt
->salt_len
= 24;
19533 salt
->salt_iter
= ROUNDS_RAR3
;
19535 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19536 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19538 digest
[0] = 0xc43d7b00;
19539 digest
[1] = 0x40070000;
19543 return (PARSER_OK
);
19546 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19548 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19550 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19552 u32
*digest
= (u32
*) hash_buf
->digest
;
19554 salt_t
*salt
= hash_buf
->salt
;
19556 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19562 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19564 char *param1_pos
= strchr (param0_pos
, '$');
19566 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19568 u32 param0_len
= param1_pos
- param0_pos
;
19572 char *param2_pos
= strchr (param1_pos
, '$');
19574 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19576 u32 param1_len
= param2_pos
- param1_pos
;
19580 char *param3_pos
= strchr (param2_pos
, '$');
19582 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19584 u32 param2_len
= param3_pos
- param2_pos
;
19588 char *param4_pos
= strchr (param3_pos
, '$');
19590 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19592 u32 param3_len
= param4_pos
- param3_pos
;
19596 char *param5_pos
= strchr (param4_pos
, '$');
19598 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19600 u32 param4_len
= param5_pos
- param4_pos
;
19604 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19606 char *salt_buf
= param1_pos
;
19607 char *iv
= param3_pos
;
19608 char *pswcheck
= param5_pos
;
19610 const uint salt_len
= atoi (param0_pos
);
19611 const uint iterations
= atoi (param2_pos
);
19612 const uint pswcheck_len
= atoi (param4_pos
);
19618 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19619 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19620 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19622 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19623 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19624 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19630 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19631 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19632 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19633 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19635 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19636 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19637 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19638 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19640 salt
->salt_len
= 16;
19642 salt
->salt_sign
[0] = iterations
;
19644 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19650 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19651 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19655 return (PARSER_OK
);
19658 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19660 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19662 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19664 u32
*digest
= (u32
*) hash_buf
->digest
;
19666 salt_t
*salt
= hash_buf
->salt
;
19668 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19675 char *account_pos
= input_buf
+ 11 + 1;
19681 if (account_pos
[0] == '*')
19685 data_pos
= strchr (account_pos
, '*');
19690 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19692 uint account_len
= data_pos
- account_pos
+ 1;
19694 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19699 data_len
= input_len
- 11 - 1 - account_len
- 2;
19701 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19705 /* assume $krb5tgs$23$checksum$edata2 */
19706 data_pos
= account_pos
;
19708 memcpy (krb5tgs
->account_info
, "**", 3);
19710 data_len
= input_len
- 11 - 1 - 1;
19713 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19715 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19717 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19719 const char p0
= data_pos
[i
+ 0];
19720 const char p1
= data_pos
[i
+ 1];
19722 *checksum_ptr
++ = hex_convert (p1
) << 0
19723 | hex_convert (p0
) << 4;
19726 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19728 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19731 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19733 const char p0
= data_pos
[i
+ 0];
19734 const char p1
= data_pos
[i
+ 1];
19735 *edata_ptr
++ = hex_convert (p1
) << 0
19736 | hex_convert (p0
) << 4;
19739 /* this is needed for hmac_md5 */
19740 *edata_ptr
++ = 0x80;
19742 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19743 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19744 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19745 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19747 salt
->salt_len
= 32;
19749 digest
[0] = krb5tgs
->checksum
[0];
19750 digest
[1] = krb5tgs
->checksum
[1];
19751 digest
[2] = krb5tgs
->checksum
[2];
19752 digest
[3] = krb5tgs
->checksum
[3];
19754 return (PARSER_OK
);
19757 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19759 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19761 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19763 u32
*digest
= (u32
*) hash_buf
->digest
;
19765 salt_t
*salt
= hash_buf
->salt
;
19772 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19776 char *wrapped_key_pos
;
19780 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19782 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19784 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19786 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19791 data_pos
= salt_pos
;
19793 wrapped_key_pos
= strchr (salt_pos
, '*');
19795 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19797 uint salt_len
= wrapped_key_pos
- salt_pos
;
19799 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19804 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19806 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19808 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19809 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19810 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19811 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19815 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19816 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19817 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19818 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19819 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19820 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19822 salt
->salt_len
= 40;
19824 digest
[0] = salt
->salt_buf
[0];
19825 digest
[1] = salt
->salt_buf
[1];
19826 digest
[2] = salt
->salt_buf
[2];
19827 digest
[3] = salt
->salt_buf
[3];
19829 return (PARSER_OK
);
19832 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19834 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19836 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19838 u32
*digest
= (u32
*) hash_buf
->digest
;
19840 salt_t
*salt
= hash_buf
->salt
;
19842 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19852 char *algorithm_pos
;
19854 char *final_random_seed_pos
;
19855 u32 final_random_seed_len
;
19857 char *transf_random_seed_pos
;
19858 u32 transf_random_seed_len
;
19863 /* default is no keyfile provided */
19864 char *keyfile_len_pos
;
19865 u32 keyfile_len
= 0;
19866 u32 is_keyfile_present
= 0;
19867 char *keyfile_inline_pos
;
19870 /* specific to version 1 */
19871 char *contents_len_pos
;
19873 char *contents_pos
;
19875 /* specific to version 2 */
19876 char *expected_bytes_pos
;
19877 u32 expected_bytes_len
;
19879 char *contents_hash_pos
;
19880 u32 contents_hash_len
;
19882 version_pos
= input_buf
+ 8 + 1 + 1;
19884 keepass
->version
= atoi (version_pos
);
19886 rounds_pos
= strchr (version_pos
, '*');
19888 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19892 salt
->salt_iter
= (atoi (rounds_pos
));
19894 algorithm_pos
= strchr (rounds_pos
, '*');
19896 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19900 keepass
->algorithm
= atoi (algorithm_pos
);
19902 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19904 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19906 final_random_seed_pos
++;
19908 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19909 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19910 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19911 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19913 if (keepass
->version
== 2)
19915 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19916 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19917 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19918 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19921 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19923 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19925 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19927 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19928 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19930 transf_random_seed_pos
++;
19932 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19933 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19934 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19935 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19936 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19937 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19938 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19939 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19941 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19943 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19945 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19947 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19951 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19952 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19953 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19954 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19956 if (keepass
->version
== 1)
19958 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19960 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19962 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19964 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19966 contents_hash_pos
++;
19968 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19969 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19970 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19971 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19972 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19973 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19974 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19975 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19977 /* get length of contents following */
19978 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19980 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19982 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19984 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19988 u32 inline_flag
= atoi (inline_flag_pos
);
19990 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19992 contents_len_pos
= strchr (inline_flag_pos
, '*');
19994 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19996 contents_len_pos
++;
19998 contents_len
= atoi (contents_len_pos
);
20000 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20002 contents_pos
= strchr (contents_len_pos
, '*');
20004 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20010 keepass
->contents_len
= contents_len
;
20012 contents_len
= contents_len
/ 4;
20014 keyfile_inline_pos
= strchr (contents_pos
, '*');
20016 u32 real_contents_len
;
20018 if (keyfile_inline_pos
== NULL
)
20019 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20022 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20023 keyfile_inline_pos
++;
20024 is_keyfile_present
= 1;
20027 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20029 for (i
= 0; i
< contents_len
; i
++)
20030 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20032 else if (keepass
->version
== 2)
20034 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20036 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20038 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20040 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20042 expected_bytes_pos
++;
20044 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20045 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20046 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20047 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20048 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20049 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20050 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20051 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20053 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20055 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20057 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20059 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20061 contents_hash_pos
++;
20063 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20064 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20065 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20066 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20067 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20068 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20069 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20070 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20072 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20074 if (keyfile_inline_pos
== NULL
)
20075 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20078 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20079 keyfile_inline_pos
++;
20080 is_keyfile_present
= 1;
20082 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20085 if (is_keyfile_present
!= 0)
20087 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20091 keyfile_len
= atoi (keyfile_len_pos
);
20093 keepass
->keyfile_len
= keyfile_len
;
20095 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20097 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20099 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20103 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20105 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20107 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20108 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20109 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20110 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20111 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20112 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20113 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20114 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20117 digest
[0] = keepass
->enc_iv
[0];
20118 digest
[1] = keepass
->enc_iv
[1];
20119 digest
[2] = keepass
->enc_iv
[2];
20120 digest
[3] = keepass
->enc_iv
[3];
20122 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20123 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20124 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20125 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20126 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20127 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20128 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20129 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20131 return (PARSER_OK
);
20134 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20136 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20138 u32
*digest
= (u32
*) hash_buf
->digest
;
20140 salt_t
*salt
= hash_buf
->salt
;
20142 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20143 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20144 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20145 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20146 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20147 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20148 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20149 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20151 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20153 uint salt_len
= input_len
- 64 - 1;
20155 char *salt_buf
= input_buf
+ 64 + 1;
20157 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20159 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20161 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20163 salt
->salt_len
= salt_len
;
20166 * we can precompute the first sha256 transform
20169 uint w
[16] = { 0 };
20171 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20172 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20173 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20174 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20175 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20176 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20177 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20178 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20179 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20180 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20181 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20182 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20183 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20184 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20185 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20186 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20188 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20190 sha256_64 (w
, pc256
);
20192 salt
->salt_buf_pc
[0] = pc256
[0];
20193 salt
->salt_buf_pc
[1] = pc256
[1];
20194 salt
->salt_buf_pc
[2] = pc256
[2];
20195 salt
->salt_buf_pc
[3] = pc256
[3];
20196 salt
->salt_buf_pc
[4] = pc256
[4];
20197 salt
->salt_buf_pc
[5] = pc256
[5];
20198 salt
->salt_buf_pc
[6] = pc256
[6];
20199 salt
->salt_buf_pc
[7] = pc256
[7];
20201 digest
[0] -= pc256
[0];
20202 digest
[1] -= pc256
[1];
20203 digest
[2] -= pc256
[2];
20204 digest
[3] -= pc256
[3];
20205 digest
[4] -= pc256
[4];
20206 digest
[5] -= pc256
[5];
20207 digest
[6] -= pc256
[6];
20208 digest
[7] -= pc256
[7];
20210 return (PARSER_OK
);
20213 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20215 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20217 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20219 u32
*digest
= (u32
*) hash_buf
->digest
;
20221 salt_t
*salt
= hash_buf
->salt
;
20227 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20229 char *data_buf_pos
= strchr (data_len_pos
, '$');
20231 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20233 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20235 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20236 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20240 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20242 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20244 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20246 u32 data_len
= atoi (data_len_pos
);
20248 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20254 char *salt_pos
= data_buf_pos
;
20256 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20257 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20258 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20259 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20261 // this is actually the CT, which is also the hash later (if matched)
20263 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20264 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20265 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20266 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20268 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20270 salt
->salt_iter
= 10 - 1;
20276 digest
[0] = salt
->salt_buf
[4];
20277 digest
[1] = salt
->salt_buf
[5];
20278 digest
[2] = salt
->salt_buf
[6];
20279 digest
[3] = salt
->salt_buf
[7];
20281 return (PARSER_OK
);
20284 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20286 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20288 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20290 u32
*digest
= (u32
*) hash_buf
->digest
;
20292 salt_t
*salt
= hash_buf
->salt
;
20298 char *salt_pos
= input_buf
+ 11 + 1;
20300 char *iter_pos
= strchr (salt_pos
, ',');
20302 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20304 u32 salt_len
= iter_pos
- salt_pos
;
20306 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20310 char *hash_pos
= strchr (iter_pos
, ',');
20312 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20314 u32 iter_len
= hash_pos
- iter_pos
;
20316 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20320 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20322 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20328 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20329 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20330 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20331 salt
->salt_buf
[3] = 0x00018000;
20333 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20334 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20335 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20336 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20338 salt
->salt_len
= salt_len
/ 2;
20340 salt
->salt_iter
= atoi (iter_pos
) - 1;
20346 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20347 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20348 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20349 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20350 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20351 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20352 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20353 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20355 return (PARSER_OK
);
20358 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20360 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20362 u32
*digest
= (u32
*) hash_buf
->digest
;
20364 salt_t
*salt
= hash_buf
->salt
;
20370 char *hash_pos
= input_buf
+ 64;
20371 char *salt1_pos
= input_buf
+ 128;
20372 char *salt2_pos
= input_buf
;
20378 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20379 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20380 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20381 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20383 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20384 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20385 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20386 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20388 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20389 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20390 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20391 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20393 salt
->salt_len
= 48;
20395 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20401 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20402 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20403 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20404 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20405 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20406 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20407 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20408 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20410 return (PARSER_OK
);
20413 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20415 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20417 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20418 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20420 u32
*digest
= (u32
*) hash_buf
->digest
;
20422 salt_t
*salt
= hash_buf
->salt
;
20424 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20430 char *param0_pos
= input_buf
+ 6 + 1;
20432 char *param1_pos
= strchr (param0_pos
, '*');
20434 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20436 u32 param0_len
= param1_pos
- param0_pos
;
20440 char *param2_pos
= strchr (param1_pos
, '*');
20442 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20444 u32 param1_len
= param2_pos
- param1_pos
;
20448 char *param3_pos
= strchr (param2_pos
, '*');
20450 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20452 u32 param2_len
= param3_pos
- param2_pos
;
20456 char *param4_pos
= strchr (param3_pos
, '*');
20458 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20460 u32 param3_len
= param4_pos
- param3_pos
;
20464 char *param5_pos
= strchr (param4_pos
, '*');
20466 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20468 u32 param4_len
= param5_pos
- param4_pos
;
20472 char *param6_pos
= strchr (param5_pos
, '*');
20474 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20476 u32 param5_len
= param6_pos
- param5_pos
;
20480 char *param7_pos
= strchr (param6_pos
, '*');
20482 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20484 u32 param6_len
= param7_pos
- param6_pos
;
20488 char *param8_pos
= strchr (param7_pos
, '*');
20490 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20492 u32 param7_len
= param8_pos
- param7_pos
;
20496 const uint type
= atoi (param0_pos
);
20497 const uint mode
= atoi (param1_pos
);
20498 const uint magic
= atoi (param2_pos
);
20500 char *salt_buf
= param3_pos
;
20502 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20504 const uint compress_length
= atoi (param5_pos
);
20506 char *data_buf
= param6_pos
;
20507 char *auth
= param7_pos
;
20513 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20515 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20517 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20519 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20521 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20523 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20525 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20527 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20529 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20531 if (type
!= 0) return (PARSER_SALT_VALUE
);
20533 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20535 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20537 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20545 zip2
->magic
= magic
;
20549 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20550 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20551 zip2
->salt_buf
[2] = 0;
20552 zip2
->salt_buf
[3] = 0;
20554 zip2
->salt_len
= 8;
20556 else if (mode
== 2)
20558 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20559 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20560 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20561 zip2
->salt_buf
[3] = 0;
20563 zip2
->salt_len
= 12;
20565 else if (mode
== 3)
20567 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20568 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20569 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20570 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20572 zip2
->salt_len
= 16;
20575 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20576 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20577 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20578 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20580 zip2
->verify_bytes
= verify_bytes
;
20582 zip2
->compress_length
= compress_length
;
20584 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20586 for (uint i
= 0; i
< param6_len
; i
+= 2)
20588 const char p0
= data_buf
[i
+ 0];
20589 const char p1
= data_buf
[i
+ 1];
20591 *data_buf_ptr
++ = hex_convert (p1
) << 0
20592 | hex_convert (p0
) << 4;
20597 *data_buf_ptr
= 0x80;
20599 char *auth_ptr
= (char *) zip2
->auth_buf
;
20601 for (uint i
= 0; i
< param7_len
; i
+= 2)
20603 const char p0
= auth
[i
+ 0];
20604 const char p1
= auth
[i
+ 1];
20606 *auth_ptr
++ = hex_convert (p1
) << 0
20607 | hex_convert (p0
) << 4;
20616 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20617 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20618 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20619 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20620 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20621 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20622 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20623 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20625 salt
->salt_len
= 32;
20627 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20630 * digest buf (fake)
20633 digest
[0] = zip2
->auth_buf
[0];
20634 digest
[1] = zip2
->auth_buf
[1];
20635 digest
[2] = zip2
->auth_buf
[2];
20636 digest
[3] = zip2
->auth_buf
[3];
20638 return (PARSER_OK
);
20641 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20643 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20645 u32
*digest
= (u32
*) hash_buf
->digest
;
20647 salt_t
*salt
= hash_buf
->salt
;
20649 win8phone_t
*esalt
= hash_buf
->esalt
;
20651 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20652 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20653 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20654 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20655 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20656 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20657 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20658 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20660 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20662 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20664 u32
*salt_buf
= esalt
->salt_buf
;
20666 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20668 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20671 salt
->salt_buf
[0] = salt_buf
[0];
20672 salt
->salt_buf
[1] = salt_buf
[1];
20673 salt
->salt_buf
[2] = salt_buf
[2];
20674 salt
->salt_buf
[3] = salt_buf
[3];
20675 salt
->salt_buf
[4] = salt_buf
[4];
20676 salt
->salt_buf
[5] = salt_buf
[5];
20677 salt
->salt_buf
[6] = salt_buf
[6];
20678 salt
->salt_buf
[7] = salt_buf
[7];
20680 salt
->salt_len
= 64;
20682 return (PARSER_OK
);
20686 * parallel running threads
20691 BOOL WINAPI
sigHandler_default (DWORD sig
)
20695 case CTRL_CLOSE_EVENT
:
20698 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20699 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20700 * function otherwise it is too late (e.g. after returning from this function)
20705 SetConsoleCtrlHandler (NULL
, TRUE
);
20712 case CTRL_LOGOFF_EVENT
:
20713 case CTRL_SHUTDOWN_EVENT
:
20717 SetConsoleCtrlHandler (NULL
, TRUE
);
20725 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20729 case CTRL_CLOSE_EVENT
:
20733 SetConsoleCtrlHandler (NULL
, TRUE
);
20740 case CTRL_LOGOFF_EVENT
:
20741 case CTRL_SHUTDOWN_EVENT
:
20745 SetConsoleCtrlHandler (NULL
, TRUE
);
20753 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20755 if (callback
== NULL
)
20757 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20761 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20767 void sigHandler_default (int sig
)
20771 signal (sig
, NULL
);
20774 void sigHandler_benchmark (int sig
)
20778 signal (sig
, NULL
);
20781 void hc_signal (void (callback
) (int))
20783 if (callback
== NULL
) callback
= SIG_DFL
;
20785 signal (SIGINT
, callback
);
20786 signal (SIGTERM
, callback
);
20787 signal (SIGABRT
, callback
);
20792 void status_display ();
20794 void *thread_keypress (void *p
)
20796 uint quiet
= data
.quiet
;
20800 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20802 int ch
= tty_getchar();
20804 if (ch
== -1) break;
20806 if (ch
== 0) continue;
20808 //https://github.com/hashcat/hashcat/issues/302
20813 hc_thread_mutex_lock (mux_display
);
20829 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20830 if (quiet
== 0) fflush (stdout
);
20842 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20843 if (quiet
== 0) fflush (stdout
);
20855 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20856 if (quiet
== 0) fflush (stdout
);
20868 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20869 if (quiet
== 0) fflush (stdout
);
20877 stop_at_checkpoint ();
20881 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20882 if (quiet
== 0) fflush (stdout
);
20895 //https://github.com/hashcat/hashcat/issues/302
20900 hc_thread_mutex_unlock (mux_display
);
20912 bool class_num (const u8 c
)
20914 return ((c
>= '0') && (c
<= '9'));
20917 bool class_lower (const u8 c
)
20919 return ((c
>= 'a') && (c
<= 'z'));
20922 bool class_upper (const u8 c
)
20924 return ((c
>= 'A') && (c
<= 'Z'));
20927 bool class_alpha (const u8 c
)
20929 return (class_lower (c
) || class_upper (c
));
20932 int conv_ctoi (const u8 c
)
20938 else if (class_upper (c
))
20940 return c
- 'A' + 10;
20946 int conv_itoc (const u8 c
)
20954 return c
+ 'A' - 10;
20964 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20965 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20966 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20967 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20968 #define MAX_KERNEL_RULES 255
20969 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20970 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20971 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20973 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20974 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20975 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20976 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20978 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20983 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20985 switch (rule_buf
[rule_pos
])
20991 case RULE_OP_MANGLE_NOOP
:
20992 SET_NAME (rule
, rule_buf
[rule_pos
]);
20995 case RULE_OP_MANGLE_LREST
:
20996 SET_NAME (rule
, rule_buf
[rule_pos
]);
20999 case RULE_OP_MANGLE_UREST
:
21000 SET_NAME (rule
, rule_buf
[rule_pos
]);
21003 case RULE_OP_MANGLE_LREST_UFIRST
:
21004 SET_NAME (rule
, rule_buf
[rule_pos
]);
21007 case RULE_OP_MANGLE_UREST_LFIRST
:
21008 SET_NAME (rule
, rule_buf
[rule_pos
]);
21011 case RULE_OP_MANGLE_TREST
:
21012 SET_NAME (rule
, rule_buf
[rule_pos
]);
21015 case RULE_OP_MANGLE_TOGGLE_AT
:
21016 SET_NAME (rule
, rule_buf
[rule_pos
]);
21017 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21020 case RULE_OP_MANGLE_REVERSE
:
21021 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 case RULE_OP_MANGLE_DUPEWORD
:
21025 SET_NAME (rule
, rule_buf
[rule_pos
]);
21028 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21029 SET_NAME (rule
, rule_buf
[rule_pos
]);
21030 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_REFLECT
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_ROTATE_LEFT
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21041 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21042 SET_NAME (rule
, rule_buf
[rule_pos
]);
21045 case RULE_OP_MANGLE_APPEND
:
21046 SET_NAME (rule
, rule_buf
[rule_pos
]);
21047 SET_P0 (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_PREPEND
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21052 SET_P0 (rule
, rule_buf
[rule_pos
]);
21055 case RULE_OP_MANGLE_DELETE_FIRST
:
21056 SET_NAME (rule
, rule_buf
[rule_pos
]);
21059 case RULE_OP_MANGLE_DELETE_LAST
:
21060 SET_NAME (rule
, rule_buf
[rule_pos
]);
21063 case RULE_OP_MANGLE_DELETE_AT
:
21064 SET_NAME (rule
, rule_buf
[rule_pos
]);
21065 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_EXTRACT
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21070 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21071 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21074 case RULE_OP_MANGLE_OMIT
:
21075 SET_NAME (rule
, rule_buf
[rule_pos
]);
21076 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21077 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21080 case RULE_OP_MANGLE_INSERT
:
21081 SET_NAME (rule
, rule_buf
[rule_pos
]);
21082 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21083 SET_P1 (rule
, rule_buf
[rule_pos
]);
21086 case RULE_OP_MANGLE_OVERSTRIKE
:
21087 SET_NAME (rule
, rule_buf
[rule_pos
]);
21088 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21089 SET_P1 (rule
, rule_buf
[rule_pos
]);
21092 case RULE_OP_MANGLE_TRUNCATE_AT
:
21093 SET_NAME (rule
, rule_buf
[rule_pos
]);
21094 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21097 case RULE_OP_MANGLE_REPLACE
:
21098 SET_NAME (rule
, rule_buf
[rule_pos
]);
21099 SET_P0 (rule
, rule_buf
[rule_pos
]);
21100 SET_P1 (rule
, rule_buf
[rule_pos
]);
21103 case RULE_OP_MANGLE_PURGECHAR
:
21107 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21111 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21112 SET_NAME (rule
, rule_buf
[rule_pos
]);
21113 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21116 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21117 SET_NAME (rule
, rule_buf
[rule_pos
]);
21118 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21121 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21122 SET_NAME (rule
, rule_buf
[rule_pos
]);
21125 case RULE_OP_MANGLE_SWITCH_FIRST
:
21126 SET_NAME (rule
, rule_buf
[rule_pos
]);
21129 case RULE_OP_MANGLE_SWITCH_LAST
:
21130 SET_NAME (rule
, rule_buf
[rule_pos
]);
21133 case RULE_OP_MANGLE_SWITCH_AT
:
21134 SET_NAME (rule
, rule_buf
[rule_pos
]);
21135 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21136 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21139 case RULE_OP_MANGLE_CHR_SHIFTL
:
21140 SET_NAME (rule
, rule_buf
[rule_pos
]);
21141 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21144 case RULE_OP_MANGLE_CHR_SHIFTR
:
21145 SET_NAME (rule
, rule_buf
[rule_pos
]);
21146 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21149 case RULE_OP_MANGLE_CHR_INCR
:
21150 SET_NAME (rule
, rule_buf
[rule_pos
]);
21151 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21154 case RULE_OP_MANGLE_CHR_DECR
:
21155 SET_NAME (rule
, rule_buf
[rule_pos
]);
21156 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21159 case RULE_OP_MANGLE_REPLACE_NP1
:
21160 SET_NAME (rule
, rule_buf
[rule_pos
]);
21161 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21164 case RULE_OP_MANGLE_REPLACE_NM1
:
21165 SET_NAME (rule
, rule_buf
[rule_pos
]);
21166 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21169 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21170 SET_NAME (rule
, rule_buf
[rule_pos
]);
21171 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21174 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21175 SET_NAME (rule
, rule_buf
[rule_pos
]);
21176 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21179 case RULE_OP_MANGLE_TITLE
:
21180 SET_NAME (rule
, rule_buf
[rule_pos
]);
21189 if (rule_pos
< rule_len
) return (-1);
21194 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21198 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21202 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21206 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21210 case RULE_OP_MANGLE_NOOP
:
21211 rule_buf
[rule_pos
] = rule_cmd
;
21214 case RULE_OP_MANGLE_LREST
:
21215 rule_buf
[rule_pos
] = rule_cmd
;
21218 case RULE_OP_MANGLE_UREST
:
21219 rule_buf
[rule_pos
] = rule_cmd
;
21222 case RULE_OP_MANGLE_LREST_UFIRST
:
21223 rule_buf
[rule_pos
] = rule_cmd
;
21226 case RULE_OP_MANGLE_UREST_LFIRST
:
21227 rule_buf
[rule_pos
] = rule_cmd
;
21230 case RULE_OP_MANGLE_TREST
:
21231 rule_buf
[rule_pos
] = rule_cmd
;
21234 case RULE_OP_MANGLE_TOGGLE_AT
:
21235 rule_buf
[rule_pos
] = rule_cmd
;
21236 GET_P0_CONV (rule
);
21239 case RULE_OP_MANGLE_REVERSE
:
21240 rule_buf
[rule_pos
] = rule_cmd
;
21243 case RULE_OP_MANGLE_DUPEWORD
:
21244 rule_buf
[rule_pos
] = rule_cmd
;
21247 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21248 rule_buf
[rule_pos
] = rule_cmd
;
21249 GET_P0_CONV (rule
);
21252 case RULE_OP_MANGLE_REFLECT
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21256 case RULE_OP_MANGLE_ROTATE_LEFT
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21260 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21261 rule_buf
[rule_pos
] = rule_cmd
;
21264 case RULE_OP_MANGLE_APPEND
:
21265 rule_buf
[rule_pos
] = rule_cmd
;
21269 case RULE_OP_MANGLE_PREPEND
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21274 case RULE_OP_MANGLE_DELETE_FIRST
:
21275 rule_buf
[rule_pos
] = rule_cmd
;
21278 case RULE_OP_MANGLE_DELETE_LAST
:
21279 rule_buf
[rule_pos
] = rule_cmd
;
21282 case RULE_OP_MANGLE_DELETE_AT
:
21283 rule_buf
[rule_pos
] = rule_cmd
;
21284 GET_P0_CONV (rule
);
21287 case RULE_OP_MANGLE_EXTRACT
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21289 GET_P0_CONV (rule
);
21290 GET_P1_CONV (rule
);
21293 case RULE_OP_MANGLE_OMIT
:
21294 rule_buf
[rule_pos
] = rule_cmd
;
21295 GET_P0_CONV (rule
);
21296 GET_P1_CONV (rule
);
21299 case RULE_OP_MANGLE_INSERT
:
21300 rule_buf
[rule_pos
] = rule_cmd
;
21301 GET_P0_CONV (rule
);
21305 case RULE_OP_MANGLE_OVERSTRIKE
:
21306 rule_buf
[rule_pos
] = rule_cmd
;
21307 GET_P0_CONV (rule
);
21311 case RULE_OP_MANGLE_TRUNCATE_AT
:
21312 rule_buf
[rule_pos
] = rule_cmd
;
21313 GET_P0_CONV (rule
);
21316 case RULE_OP_MANGLE_REPLACE
:
21317 rule_buf
[rule_pos
] = rule_cmd
;
21322 case RULE_OP_MANGLE_PURGECHAR
:
21326 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21330 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21331 rule_buf
[rule_pos
] = rule_cmd
;
21332 GET_P0_CONV (rule
);
21335 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21336 rule_buf
[rule_pos
] = rule_cmd
;
21337 GET_P0_CONV (rule
);
21340 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21341 rule_buf
[rule_pos
] = rule_cmd
;
21344 case RULE_OP_MANGLE_SWITCH_FIRST
:
21345 rule_buf
[rule_pos
] = rule_cmd
;
21348 case RULE_OP_MANGLE_SWITCH_LAST
:
21349 rule_buf
[rule_pos
] = rule_cmd
;
21352 case RULE_OP_MANGLE_SWITCH_AT
:
21353 rule_buf
[rule_pos
] = rule_cmd
;
21354 GET_P0_CONV (rule
);
21355 GET_P1_CONV (rule
);
21358 case RULE_OP_MANGLE_CHR_SHIFTL
:
21359 rule_buf
[rule_pos
] = rule_cmd
;
21360 GET_P0_CONV (rule
);
21363 case RULE_OP_MANGLE_CHR_SHIFTR
:
21364 rule_buf
[rule_pos
] = rule_cmd
;
21365 GET_P0_CONV (rule
);
21368 case RULE_OP_MANGLE_CHR_INCR
:
21369 rule_buf
[rule_pos
] = rule_cmd
;
21370 GET_P0_CONV (rule
);
21373 case RULE_OP_MANGLE_CHR_DECR
:
21374 rule_buf
[rule_pos
] = rule_cmd
;
21375 GET_P0_CONV (rule
);
21378 case RULE_OP_MANGLE_REPLACE_NP1
:
21379 rule_buf
[rule_pos
] = rule_cmd
;
21380 GET_P0_CONV (rule
);
21383 case RULE_OP_MANGLE_REPLACE_NM1
:
21384 rule_buf
[rule_pos
] = rule_cmd
;
21385 GET_P0_CONV (rule
);
21388 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21389 rule_buf
[rule_pos
] = rule_cmd
;
21390 GET_P0_CONV (rule
);
21393 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21394 rule_buf
[rule_pos
] = rule_cmd
;
21395 GET_P0_CONV (rule
);
21398 case RULE_OP_MANGLE_TITLE
:
21399 rule_buf
[rule_pos
] = rule_cmd
;
21403 return rule_pos
- 1;
21421 * CPU rules : this is from hashcat sources, cpu based rules
21424 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21425 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21427 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21428 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21429 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21431 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21432 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21433 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21435 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21439 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21444 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21448 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21453 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21457 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21462 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21467 for (l
= 0; l
< arr_len
; l
++)
21469 r
= arr_len
- 1 - l
;
21473 MANGLE_SWITCH (arr
, l
, r
);
21479 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21481 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21483 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21485 return (arr_len
* 2);
21488 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21490 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21492 int orig_len
= arr_len
;
21496 for (i
= 0; i
< times
; i
++)
21498 memcpy (&arr
[arr_len
], arr
, orig_len
);
21500 arr_len
+= orig_len
;
21506 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21508 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21510 mangle_double (arr
, arr_len
);
21512 mangle_reverse (arr
+ arr_len
, arr_len
);
21514 return (arr_len
* 2);
21517 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21522 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21524 MANGLE_SWITCH (arr
, l
, r
);
21530 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21535 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21537 MANGLE_SWITCH (arr
, l
, r
);
21543 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21545 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21549 return (arr_len
+ 1);
21552 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21554 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21558 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21560 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21565 return (arr_len
+ 1);
21568 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21570 if (upos
>= arr_len
) return (arr_len
);
21574 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21576 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21579 return (arr_len
- 1);
21582 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21584 if (upos
>= arr_len
) return (arr_len
);
21586 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21590 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21592 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21598 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21600 if (upos
>= arr_len
) return (arr_len
);
21602 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21606 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21608 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21611 return (arr_len
- ulen
);
21614 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21616 if (upos
>= arr_len
) return (arr_len
);
21618 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21622 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21624 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21629 return (arr_len
+ 1);
21632 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
)
21634 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21636 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21638 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21640 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21642 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21644 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21646 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21648 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21650 return (arr_len
+ arr2_cpy
);
21653 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21655 if (upos
>= arr_len
) return (arr_len
);
21662 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21664 if (upos
>= arr_len
) return (arr_len
);
21666 memset (arr
+ upos
, 0, arr_len
- upos
);
21671 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21675 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21677 if (arr
[arr_pos
] != oldc
) continue;
21679 arr
[arr_pos
] = newc
;
21685 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21691 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21693 if (arr
[arr_pos
] == c
) continue;
21695 arr
[ret_len
] = arr
[arr_pos
];
21703 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21705 if (ulen
> arr_len
) return (arr_len
);
21707 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21709 char cs
[100] = { 0 };
21711 memcpy (cs
, arr
, ulen
);
21715 for (i
= 0; i
< ulen
; i
++)
21719 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21725 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21727 if (ulen
> arr_len
) return (arr_len
);
21729 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21731 int upos
= arr_len
- ulen
;
21735 for (i
= 0; i
< ulen
; i
++)
21737 char c
= arr
[upos
+ i
];
21739 arr_len
= mangle_append (arr
, arr_len
, c
);
21745 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21747 if ( arr_len
== 0) return (arr_len
);
21748 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21750 char c
= arr
[upos
];
21754 for (i
= 0; i
< ulen
; i
++)
21756 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21762 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21764 if ( arr_len
== 0) return (arr_len
);
21765 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21769 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21771 int new_pos
= arr_pos
* 2;
21773 arr
[new_pos
] = arr
[arr_pos
];
21775 arr
[new_pos
+ 1] = arr
[arr_pos
];
21778 return (arr_len
* 2);
21781 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21783 if (upos
>= arr_len
) return (arr_len
);
21784 if (upos2
>= arr_len
) return (arr_len
);
21786 MANGLE_SWITCH (arr
, upos
, upos2
);
21791 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21793 MANGLE_SWITCH (arr
, upos
, upos2
);
21798 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21800 if (upos
>= arr_len
) return (arr_len
);
21807 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21809 if (upos
>= arr_len
) return (arr_len
);
21816 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21818 if (upos
>= arr_len
) return (arr_len
);
21825 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21827 if (upos
>= arr_len
) return (arr_len
);
21834 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21836 int upper_next
= 1;
21840 for (pos
= 0; pos
< arr_len
; pos
++)
21842 if (arr
[pos
] == ' ')
21853 MANGLE_UPPER_AT (arr
, pos
);
21857 MANGLE_LOWER_AT (arr
, pos
);
21864 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21866 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21872 for (j
= 0; j
< rp_gen_num
; j
++)
21879 switch ((char) get_random_num (0, 9))
21882 r
= get_random_num (0, sizeof (grp_op_nop
));
21883 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21887 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21888 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21889 p1
= get_random_num (0, sizeof (grp_pos
));
21890 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21894 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21895 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21896 p1
= get_random_num (1, 6);
21897 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21901 r
= get_random_num (0, sizeof (grp_op_chr
));
21902 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21903 p1
= get_random_num (0x20, 0x7e);
21904 rule_buf
[rule_pos
++] = (char) p1
;
21908 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21909 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21910 p1
= get_random_num (0x20, 0x7e);
21911 rule_buf
[rule_pos
++] = (char) p1
;
21912 p2
= get_random_num (0x20, 0x7e);
21914 p2
= get_random_num (0x20, 0x7e);
21915 rule_buf
[rule_pos
++] = (char) p2
;
21919 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21920 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21921 p1
= get_random_num (0, sizeof (grp_pos
));
21922 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21923 p2
= get_random_num (0x20, 0x7e);
21924 rule_buf
[rule_pos
++] = (char) p2
;
21928 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21929 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21930 p1
= get_random_num (0, sizeof (grp_pos
));
21931 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21932 p2
= get_random_num (0, sizeof (grp_pos
));
21934 p2
= get_random_num (0, sizeof (grp_pos
));
21935 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21939 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21940 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21941 p1
= get_random_num (0, sizeof (grp_pos
));
21942 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21943 p2
= get_random_num (1, sizeof (grp_pos
));
21945 p2
= get_random_num (1, sizeof (grp_pos
));
21946 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21950 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21951 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21952 p1
= get_random_num (0, sizeof (grp_pos
));
21953 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21954 p2
= get_random_num (1, sizeof (grp_pos
));
21955 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21956 p3
= get_random_num (0, sizeof (grp_pos
));
21957 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21965 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21967 char mem
[BLOCK_SIZE
] = { 0 };
21969 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21971 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21973 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21975 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21977 int out_len
= in_len
;
21978 int mem_len
= in_len
;
21980 memcpy (out
, in
, out_len
);
21984 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21989 switch (rule
[rule_pos
])
21994 case RULE_OP_MANGLE_NOOP
:
21997 case RULE_OP_MANGLE_LREST
:
21998 out_len
= mangle_lrest (out
, out_len
);
22001 case RULE_OP_MANGLE_UREST
:
22002 out_len
= mangle_urest (out
, out_len
);
22005 case RULE_OP_MANGLE_LREST_UFIRST
:
22006 out_len
= mangle_lrest (out
, out_len
);
22007 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22010 case RULE_OP_MANGLE_UREST_LFIRST
:
22011 out_len
= mangle_urest (out
, out_len
);
22012 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22015 case RULE_OP_MANGLE_TREST
:
22016 out_len
= mangle_trest (out
, out_len
);
22019 case RULE_OP_MANGLE_TOGGLE_AT
:
22020 NEXT_RULEPOS (rule_pos
);
22021 NEXT_RPTOI (rule
, rule_pos
, upos
);
22022 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22025 case RULE_OP_MANGLE_REVERSE
:
22026 out_len
= mangle_reverse (out
, out_len
);
22029 case RULE_OP_MANGLE_DUPEWORD
:
22030 out_len
= mangle_double (out
, out_len
);
22033 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22034 NEXT_RULEPOS (rule_pos
);
22035 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22036 out_len
= mangle_double_times (out
, out_len
, ulen
);
22039 case RULE_OP_MANGLE_REFLECT
:
22040 out_len
= mangle_reflect (out
, out_len
);
22043 case RULE_OP_MANGLE_ROTATE_LEFT
:
22044 mangle_rotate_left (out
, out_len
);
22047 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22048 mangle_rotate_right (out
, out_len
);
22051 case RULE_OP_MANGLE_APPEND
:
22052 NEXT_RULEPOS (rule_pos
);
22053 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22056 case RULE_OP_MANGLE_PREPEND
:
22057 NEXT_RULEPOS (rule_pos
);
22058 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22061 case RULE_OP_MANGLE_DELETE_FIRST
:
22062 out_len
= mangle_delete_at (out
, out_len
, 0);
22065 case RULE_OP_MANGLE_DELETE_LAST
:
22066 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22069 case RULE_OP_MANGLE_DELETE_AT
:
22070 NEXT_RULEPOS (rule_pos
);
22071 NEXT_RPTOI (rule
, rule_pos
, upos
);
22072 out_len
= mangle_delete_at (out
, out_len
, upos
);
22075 case RULE_OP_MANGLE_EXTRACT
:
22076 NEXT_RULEPOS (rule_pos
);
22077 NEXT_RPTOI (rule
, rule_pos
, upos
);
22078 NEXT_RULEPOS (rule_pos
);
22079 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22080 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22083 case RULE_OP_MANGLE_OMIT
:
22084 NEXT_RULEPOS (rule_pos
);
22085 NEXT_RPTOI (rule
, rule_pos
, upos
);
22086 NEXT_RULEPOS (rule_pos
);
22087 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22088 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22091 case RULE_OP_MANGLE_INSERT
:
22092 NEXT_RULEPOS (rule_pos
);
22093 NEXT_RPTOI (rule
, rule_pos
, upos
);
22094 NEXT_RULEPOS (rule_pos
);
22095 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22098 case RULE_OP_MANGLE_OVERSTRIKE
:
22099 NEXT_RULEPOS (rule_pos
);
22100 NEXT_RPTOI (rule
, rule_pos
, upos
);
22101 NEXT_RULEPOS (rule_pos
);
22102 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22105 case RULE_OP_MANGLE_TRUNCATE_AT
:
22106 NEXT_RULEPOS (rule_pos
);
22107 NEXT_RPTOI (rule
, rule_pos
, upos
);
22108 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22111 case RULE_OP_MANGLE_REPLACE
:
22112 NEXT_RULEPOS (rule_pos
);
22113 NEXT_RULEPOS (rule_pos
);
22114 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22117 case RULE_OP_MANGLE_PURGECHAR
:
22118 NEXT_RULEPOS (rule_pos
);
22119 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22122 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22126 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22127 NEXT_RULEPOS (rule_pos
);
22128 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22129 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22132 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22133 NEXT_RULEPOS (rule_pos
);
22134 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22135 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22138 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22139 out_len
= mangle_dupechar (out
, out_len
);
22142 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22143 NEXT_RULEPOS (rule_pos
);
22144 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22145 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22148 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22149 NEXT_RULEPOS (rule_pos
);
22150 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22151 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22154 case RULE_OP_MANGLE_SWITCH_FIRST
:
22155 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22158 case RULE_OP_MANGLE_SWITCH_LAST
:
22159 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22162 case RULE_OP_MANGLE_SWITCH_AT
:
22163 NEXT_RULEPOS (rule_pos
);
22164 NEXT_RPTOI (rule
, rule_pos
, upos
);
22165 NEXT_RULEPOS (rule_pos
);
22166 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22167 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22170 case RULE_OP_MANGLE_CHR_SHIFTL
:
22171 NEXT_RULEPOS (rule_pos
);
22172 NEXT_RPTOI (rule
, rule_pos
, upos
);
22173 mangle_chr_shiftl (out
, out_len
, upos
);
22176 case RULE_OP_MANGLE_CHR_SHIFTR
:
22177 NEXT_RULEPOS (rule_pos
);
22178 NEXT_RPTOI (rule
, rule_pos
, upos
);
22179 mangle_chr_shiftr (out
, out_len
, upos
);
22182 case RULE_OP_MANGLE_CHR_INCR
:
22183 NEXT_RULEPOS (rule_pos
);
22184 NEXT_RPTOI (rule
, rule_pos
, upos
);
22185 mangle_chr_incr (out
, out_len
, upos
);
22188 case RULE_OP_MANGLE_CHR_DECR
:
22189 NEXT_RULEPOS (rule_pos
);
22190 NEXT_RPTOI (rule
, rule_pos
, upos
);
22191 mangle_chr_decr (out
, out_len
, upos
);
22194 case RULE_OP_MANGLE_REPLACE_NP1
:
22195 NEXT_RULEPOS (rule_pos
);
22196 NEXT_RPTOI (rule
, rule_pos
, upos
);
22197 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22200 case RULE_OP_MANGLE_REPLACE_NM1
:
22201 NEXT_RULEPOS (rule_pos
);
22202 NEXT_RPTOI (rule
, rule_pos
, upos
);
22203 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22206 case RULE_OP_MANGLE_TITLE
:
22207 out_len
= mangle_title (out
, out_len
);
22210 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22211 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22212 NEXT_RULEPOS (rule_pos
);
22213 NEXT_RPTOI (rule
, rule_pos
, upos
);
22214 NEXT_RULEPOS (rule_pos
);
22215 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22216 NEXT_RULEPOS (rule_pos
);
22217 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22218 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22221 case RULE_OP_MANGLE_APPEND_MEMORY
:
22222 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22223 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22224 memcpy (out
+ out_len
, mem
, mem_len
);
22225 out_len
+= mem_len
;
22228 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22229 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22230 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22231 memcpy (mem
+ mem_len
, out
, out_len
);
22232 out_len
+= mem_len
;
22233 memcpy (out
, mem
, out_len
);
22236 case RULE_OP_MEMORIZE_WORD
:
22237 memcpy (mem
, out
, out_len
);
22241 case RULE_OP_REJECT_LESS
:
22242 NEXT_RULEPOS (rule_pos
);
22243 NEXT_RPTOI (rule
, rule_pos
, upos
);
22244 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22247 case RULE_OP_REJECT_GREATER
:
22248 NEXT_RULEPOS (rule_pos
);
22249 NEXT_RPTOI (rule
, rule_pos
, upos
);
22250 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22253 case RULE_OP_REJECT_CONTAIN
:
22254 NEXT_RULEPOS (rule_pos
);
22255 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22258 case RULE_OP_REJECT_NOT_CONTAIN
:
22259 NEXT_RULEPOS (rule_pos
);
22260 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22263 case RULE_OP_REJECT_EQUAL_FIRST
:
22264 NEXT_RULEPOS (rule_pos
);
22265 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22268 case RULE_OP_REJECT_EQUAL_LAST
:
22269 NEXT_RULEPOS (rule_pos
);
22270 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22273 case RULE_OP_REJECT_EQUAL_AT
:
22274 NEXT_RULEPOS (rule_pos
);
22275 NEXT_RPTOI (rule
, rule_pos
, upos
);
22276 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22277 NEXT_RULEPOS (rule_pos
);
22278 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22281 case RULE_OP_REJECT_CONTAINS
:
22282 NEXT_RULEPOS (rule_pos
);
22283 NEXT_RPTOI (rule
, rule_pos
, upos
);
22284 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22285 NEXT_RULEPOS (rule_pos
);
22286 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22287 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22290 case RULE_OP_REJECT_MEMORY
:
22291 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22295 return (RULE_RC_SYNTAX_ERROR
);
22300 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);