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)
3487 NV_GPU_COOLER_LEVELS CoolerLevels
= { 0 };
3489 CoolerLevels
.Version
= GPU_COOLER_LEVELS_VER
| sizeof (NV_GPU_COOLER_LEVELS
);
3491 CoolerLevels
.Levels
[0].Level
= fanspeed
;
3492 CoolerLevels
.Levels
[0].Policy
= 1;
3494 if (hm_NvAPI_GPU_SetCoolerLevels (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0, &CoolerLevels
) != NVAPI_OK
) return -1;
3500 if (hm_NvAPI_GPU_RestoreCoolerSettings (data
.hm_nvapi
, data
.hm_device
[device_id
].nvapi
, 0) != NVAPI_OK
) return -1;
3510 int hm_set_fanspeed_with_device_id_xnvctrl (const uint device_id
, const int fanspeed
)
3512 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3514 if (data
.hm_xnvctrl
)
3516 if (set_fan_speed_target (data
.hm_xnvctrl
, data
.hm_device
[device_id
].xnvctrl
, fanspeed
) != 0) return -1;
3525 #endif // HAVE_HWMON
3531 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3533 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3535 if (css_cnt
> SP_PW_MAX
)
3537 log_error ("ERROR: Mask length is too long");
3542 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3544 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3546 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3547 uint cs_len
= css
[css_pos
].cs_len
;
3549 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3551 uint c
= cs_buf
[cs_pos
] & 0xff;
3558 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3560 cs_t
*cs
= &css
[css_cnt
];
3562 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3564 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3568 for (i
= 0; i
< cs
->cs_len
; i
++)
3570 const uint u
= cs
->cs_buf
[i
];
3575 for (i
= 0; i
< in_len
; i
++)
3577 uint u
= in_buf
[i
] & 0xff;
3579 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3581 if (css_uniq
[u
] == 1) continue;
3585 cs
->cs_buf
[cs
->cs_len
] = u
;
3593 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3597 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3599 uint p0
= in_buf
[in_pos
] & 0xff;
3601 if (interpret
== 1 && p0
== '?')
3605 if (in_pos
== in_len
) break;
3607 uint p1
= in_buf
[in_pos
] & 0xff;
3611 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3613 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3615 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3617 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3619 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3621 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3623 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3624 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3626 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3627 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3629 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3630 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3632 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3633 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3635 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3637 default: log_error ("Syntax error: %s", in_buf
);
3643 if (data
.hex_charset
)
3647 if (in_pos
== in_len
)
3649 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3654 uint p1
= in_buf
[in_pos
] & 0xff;
3656 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3658 log_error ("ERROR: Invalid hex character detected in mask %s", in_buf
);
3665 chr
= hex_convert (p1
) << 0;
3666 chr
|= hex_convert (p0
) << 4;
3668 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3674 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3680 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3684 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3686 sum
*= css
[css_pos
].cs_len
;
3692 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3694 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3699 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3701 char p0
= mask_buf
[mask_pos
];
3707 if (mask_pos
== mask_len
) break;
3709 char p1
= mask_buf
[mask_pos
];
3715 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3717 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3719 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3721 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3723 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3725 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3727 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3728 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3730 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3731 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3733 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3734 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3736 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3737 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3739 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3741 default: log_error ("ERROR: Syntax error: %s", mask_buf
);
3747 if (data
.hex_charset
)
3751 // if there is no 2nd hex character, show an error:
3753 if (mask_pos
== mask_len
)
3755 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3760 char p1
= mask_buf
[mask_pos
];
3762 // if they are not valid hex character, show an error:
3764 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3766 log_error ("ERROR: Invalid hex character detected in mask %s", mask_buf
);
3773 chr
|= hex_convert (p1
) << 0;
3774 chr
|= hex_convert (p0
) << 4;
3776 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3782 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3789 log_error ("ERROR: Invalid mask length (0)");
3799 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3801 for (int i
= 0; i
< css_cnt
; i
++)
3803 uint len
= css
[i
].cs_len
;
3804 u64 next
= val
/ len
;
3805 uint pos
= val
% len
;
3806 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3811 void mp_cut_at (char *mask
, uint max
)
3815 uint mask_len
= strlen (mask
);
3817 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3819 if (mask
[i
] == '?') i
++;
3825 void mp_setup_sys (cs_t
*mp_sys
)
3829 uint donec
[CHARSIZ
] = { 0 };
3831 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3832 mp_sys
[0].cs_buf
[pos
++] = chr
;
3833 mp_sys
[0].cs_len
= pos
; }
3835 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3836 mp_sys
[1].cs_buf
[pos
++] = chr
;
3837 mp_sys
[1].cs_len
= pos
; }
3839 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3840 mp_sys
[2].cs_buf
[pos
++] = chr
;
3841 mp_sys
[2].cs_len
= pos
; }
3843 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3844 mp_sys
[3].cs_buf
[pos
++] = chr
;
3845 mp_sys
[3].cs_len
= pos
; }
3847 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3848 mp_sys
[4].cs_len
= pos
; }
3850 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3851 mp_sys
[5].cs_len
= pos
; }
3854 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3856 FILE *fp
= fopen (buf
, "rb");
3858 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3860 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3864 char mp_file
[1024] = { 0 };
3866 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3870 len
= in_superchop (mp_file
);
3874 log_info ("WARNING: Charset file corrupted");
3876 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3880 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3885 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3887 mp_usr
[index
].cs_len
= 0;
3889 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3892 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3894 char *new_mask_buf
= (char *) mymalloc (256);
3900 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3902 if (css_pos
== len
) break;
3904 char p0
= mask_buf
[mask_pos
];
3906 new_mask_buf
[mask_pos
] = p0
;
3912 if (mask_pos
== mask_len
) break;
3914 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3918 if (data
.hex_charset
)
3922 if (mask_pos
== mask_len
)
3924 log_error ("ERROR: The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3929 char p1
= mask_buf
[mask_pos
];
3931 // if they are not valid hex character, show an error:
3933 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3935 log_error ("ERROR: Invalid hex character detected in mask: %s", mask_buf
);
3940 new_mask_buf
[mask_pos
] = p1
;
3945 if (css_pos
== len
) return (new_mask_buf
);
3947 myfree (new_mask_buf
);
3956 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3962 for (i
= start
; i
< stop
; i
++)
3964 sum
*= root_css_buf
[i
].cs_len
;
3970 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3974 cs_t
*cs
= &root_css_buf
[start
];
3978 for (i
= start
; i
< stop
; i
++)
3980 const u64 m
= v
% cs
->cs_len
;
3981 const u64 d
= v
/ cs
->cs_len
;
3985 const uint k
= cs
->cs_buf
[m
];
3987 pw_buf
[i
- start
] = (char) k
;
3989 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3993 int sp_comp_val (const void *p1
, const void *p2
)
3995 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3996 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3998 return b2
->val
- b1
->val
;
4001 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
4008 * Initialize hcstats
4011 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
4013 u64
*root_stats_ptr
= root_stats_buf
;
4015 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
4017 for (i
= 0; i
< SP_PW_MAX
; i
++)
4019 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
4021 root_stats_ptr
+= CHARSIZ
;
4024 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
4026 u64
*markov_stats_ptr
= markov_stats_buf
;
4028 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4030 for (i
= 0; i
< SP_PW_MAX
; i
++)
4032 for (j
= 0; j
< CHARSIZ
; j
++)
4034 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
4036 markov_stats_ptr
+= CHARSIZ
;
4046 char hcstat_tmp
[256] = { 0 };
4048 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
4050 hcstat
= hcstat_tmp
;
4053 FILE *fd
= fopen (hcstat
, "rb");
4057 log_error ("%s: %s", hcstat
, strerror (errno
));
4062 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
4064 log_error ("%s: Could not load data", hcstat
);
4071 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
4073 log_error ("%s: Could not load data", hcstat
);
4083 * Markov modifier of hcstat_table on user request
4088 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4089 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4094 /* Add all stats to first position */
4096 for (i
= 1; i
< SP_PW_MAX
; i
++)
4098 u64
*out
= root_stats_buf_by_pos
[0];
4099 u64
*in
= root_stats_buf_by_pos
[i
];
4101 for (j
= 0; j
< CHARSIZ
; j
++)
4107 for (i
= 1; i
< SP_PW_MAX
; i
++)
4109 u64
*out
= markov_stats_buf_by_key
[0][0];
4110 u64
*in
= markov_stats_buf_by_key
[i
][0];
4112 for (j
= 0; j
< CHARSIZ
; j
++)
4114 for (k
= 0; k
< CHARSIZ
; k
++)
4121 /* copy them to all pw_positions */
4123 for (i
= 1; i
< SP_PW_MAX
; i
++)
4125 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4128 for (i
= 1; i
< SP_PW_MAX
; i
++)
4130 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4138 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4140 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4142 for (i
= 0; i
< SP_PW_MAX
; i
++)
4144 root_table_buf_by_pos
[i
] = root_table_ptr
;
4146 root_table_ptr
+= CHARSIZ
;
4149 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4151 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4153 for (i
= 0; i
< SP_PW_MAX
; i
++)
4155 for (j
= 0; j
< CHARSIZ
; j
++)
4157 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4159 markov_table_ptr
+= CHARSIZ
;
4164 * Convert hcstat to tables
4167 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4169 uint key
= i
% CHARSIZ
;
4171 root_table_buf
[i
].key
= key
;
4172 root_table_buf
[i
].val
= root_stats_buf
[i
];
4175 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4177 uint key
= i
% CHARSIZ
;
4179 markov_table_buf
[i
].key
= key
;
4180 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4183 myfree (root_stats_buf
);
4184 myfree (markov_stats_buf
);
4190 for (i
= 0; i
< SP_PW_MAX
; i
++)
4192 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4195 for (i
= 0; i
< SP_PW_MAX
; i
++)
4197 for (j
= 0; j
< CHARSIZ
; j
++)
4199 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4204 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
4207 * Convert tables to css
4210 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4212 uint pw_pos
= i
/ CHARSIZ
;
4214 cs_t
*cs
= &root_css_buf
[pw_pos
];
4216 if (cs
->cs_len
== threshold
) continue;
4218 uint key
= root_table_buf
[i
].key
;
4220 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4222 cs
->cs_buf
[cs
->cs_len
] = key
;
4228 * Convert table to css
4231 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4233 uint c
= i
/ CHARSIZ
;
4235 cs_t
*cs
= &markov_css_buf
[c
];
4237 if (cs
->cs_len
== threshold
) continue;
4239 uint pw_pos
= c
/ CHARSIZ
;
4241 uint key
= markov_table_buf
[i
].key
;
4243 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4245 cs
->cs_buf
[cs
->cs_len
] = key
;
4251 for (uint i = 0; i < 8; i++)
4253 for (uint j = 0x20; j < 0x80; j++)
4255 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4257 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4259 for (uint k = 0; k < 10; k++)
4261 printf (" %u\n", ptr->cs_buf[k]);
4268 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4270 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4272 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4282 for (uint j
= 1; j
< CHARSIZ
; j
++)
4292 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4294 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4296 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4298 out
+= CHARSIZ
* CHARSIZ
;
4299 in
+= CHARSIZ
* CHARSIZ
;
4301 for (uint j
= 0; j
< CHARSIZ
; j
++)
4308 for (uint k
= 1; k
< CHARSIZ
; k
++)
4320 * mixed shared functions
4323 void dump_hex (const u8
*s
, const int sz
)
4325 for (int i
= 0; i
< sz
; i
++)
4327 log_info_nn ("%02x ", s
[i
]);
4333 void usage_mini_print (const char *progname
)
4335 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4338 void usage_big_print (const char *progname
)
4340 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4343 char *get_exec_path ()
4345 int exec_path_len
= 1024;
4347 char *exec_path
= (char *) mymalloc (exec_path_len
);
4351 char tmp
[32] = { 0 };
4353 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4355 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4359 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4363 uint size
= exec_path_len
;
4365 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4367 log_error("! executable path buffer too small\n");
4372 const int len
= strlen (exec_path
);
4375 #error Your Operating System is not supported or detected
4383 char *get_install_dir (const char *progname
)
4385 char *install_dir
= mystrdup (progname
);
4386 char *last_slash
= NULL
;
4388 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4392 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4398 install_dir
[0] = '.';
4402 return (install_dir
);
4405 char *get_profile_dir (const char *homedir
)
4407 #define DOT_HASHCAT ".hashcat"
4409 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4411 char *profile_dir
= (char *) mymalloc (len
+ 1);
4413 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4418 char *get_session_dir (const char *profile_dir
)
4420 #define SESSIONS_FOLDER "sessions"
4422 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4424 char *session_dir
= (char *) mymalloc (len
+ 1);
4426 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4431 uint
count_lines (FILE *fd
)
4435 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4441 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4443 if (nread
< 1) continue;
4447 for (i
= 0; i
< nread
; i
++)
4449 if (prev
== '\n') cnt
++;
4460 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4464 FILE *fd
= fopen (filename
, "rb");
4468 log_error ("%s: %s", filename
, strerror (errno
));
4473 #define MAX_KEY_SIZE (1024 * 1024)
4475 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4477 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4483 for (int fpos
= 0; fpos
< nread
; fpos
++)
4485 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4487 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4488 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4489 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4490 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4492 if (kpos
>= 64) kpos
= 0;
4499 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4503 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4504 if (CPU_ISSET(core
, cpu_set
)) break;
4506 thread_affinity_policy_data_t policy
= { core
};
4508 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4510 if (data
.quiet
== 0)
4512 if (rc
!= KERN_SUCCESS
)
4514 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4522 void set_cpu_affinity (char *cpu_affinity
)
4525 DWORD_PTR aff_mask
= 0;
4533 char *devices
= strdup (cpu_affinity
);
4535 char *next
= strtok (devices
, ",");
4539 uint cpu_id
= atoi (next
);
4554 log_error ("ERROR: Invalid cpu_id %u specified", cpu_id
);
4560 aff_mask
|= 1 << (cpu_id
- 1);
4562 CPU_SET ((cpu_id
- 1), &cpuset
);
4565 } while ((next
= strtok (NULL
, ",")) != NULL
);
4571 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4572 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4574 pthread_t thread
= pthread_self ();
4575 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4579 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4581 char *element
, *end
;
4583 end
= (char *) base
+ nmemb
* size
;
4585 for (element
= (char *) base
; element
< end
; element
+= size
)
4586 if (!compar (element
, key
))
4592 int sort_by_u32 (const void *v1
, const void *v2
)
4594 const u32
*s1
= (const u32
*) v1
;
4595 const u32
*s2
= (const u32
*) v2
;
4600 int sort_by_salt (const void *v1
, const void *v2
)
4602 const salt_t
*s1
= (const salt_t
*) v1
;
4603 const salt_t
*s2
= (const salt_t
*) v2
;
4605 const int res1
= s1
->salt_len
- s2
->salt_len
;
4607 if (res1
!= 0) return (res1
);
4609 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4611 if (res2
!= 0) return (res2
);
4619 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4620 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4627 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4628 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4634 int sort_by_salt_buf (const void *v1
, const void *v2
)
4636 const pot_t
*p1
= (const pot_t
*) v1
;
4637 const pot_t
*p2
= (const pot_t
*) v2
;
4639 const hash_t
*h1
= &p1
->hash
;
4640 const hash_t
*h2
= &p2
->hash
;
4642 const salt_t
*s1
= h1
->salt
;
4643 const salt_t
*s2
= h2
->salt
;
4649 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4650 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4656 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4658 const hash_t
*h1
= (const hash_t
*) v1
;
4659 const hash_t
*h2
= (const hash_t
*) v2
;
4661 const salt_t
*s1
= h1
->salt
;
4662 const salt_t
*s2
= h2
->salt
;
4664 // testphase: this should work
4669 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4670 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4673 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4674 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4675 if (s1->salt_len > s2->salt_len) return ( 1);
4676 if (s1->salt_len < s2->salt_len) return (-1);
4678 uint n = s1->salt_len;
4682 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4683 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4690 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4692 const hash_t
*h1
= (const hash_t
*) v1
;
4693 const hash_t
*h2
= (const hash_t
*) v2
;
4695 const salt_t
*s1
= h1
->salt
;
4696 const salt_t
*s2
= h2
->salt
;
4698 // 16 - 2 (since last 2 uints contain the digest)
4703 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4704 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4710 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4712 const hash_t
*h1
= (const hash_t
*) v1
;
4713 const hash_t
*h2
= (const hash_t
*) v2
;
4715 const void *d1
= h1
->digest
;
4716 const void *d2
= h2
->digest
;
4718 return data
.sort_by_digest (d1
, d2
);
4721 int sort_by_hash (const void *v1
, const void *v2
)
4723 const hash_t
*h1
= (const hash_t
*) v1
;
4724 const hash_t
*h2
= (const hash_t
*) v2
;
4728 const salt_t
*s1
= h1
->salt
;
4729 const salt_t
*s2
= h2
->salt
;
4731 int res
= sort_by_salt (s1
, s2
);
4733 if (res
!= 0) return (res
);
4736 const void *d1
= h1
->digest
;
4737 const void *d2
= h2
->digest
;
4739 return data
.sort_by_digest (d1
, d2
);
4742 int sort_by_pot (const void *v1
, const void *v2
)
4744 const pot_t
*p1
= (const pot_t
*) v1
;
4745 const pot_t
*p2
= (const pot_t
*) v2
;
4747 const hash_t
*h1
= &p1
->hash
;
4748 const hash_t
*h2
= &p2
->hash
;
4750 return sort_by_hash (h1
, h2
);
4753 int sort_by_mtime (const void *p1
, const void *p2
)
4755 const char **f1
= (const char **) p1
;
4756 const char **f2
= (const char **) p2
;
4758 struct stat s1
; stat (*f1
, &s1
);
4759 struct stat s2
; stat (*f2
, &s2
);
4761 return s2
.st_mtime
- s1
.st_mtime
;
4764 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4766 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4767 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4769 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4772 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4774 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4775 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4777 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4780 int sort_by_stringptr (const void *p1
, const void *p2
)
4782 const char **s1
= (const char **) p1
;
4783 const char **s2
= (const char **) p2
;
4785 return strcmp (*s1
, *s2
);
4788 int sort_by_dictstat (const void *s1
, const void *s2
)
4790 dictstat_t
*d1
= (dictstat_t
*) s1
;
4791 dictstat_t
*d2
= (dictstat_t
*) s2
;
4794 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4796 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4799 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4802 int sort_by_bitmap (const void *p1
, const void *p2
)
4804 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4805 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4807 return b1
->collisions
- b2
->collisions
;
4810 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4812 const u32
*d1
= (const u32
*) v1
;
4813 const u32
*d2
= (const u32
*) v2
;
4819 if (d1
[n
] > d2
[n
]) return ( 1);
4820 if (d1
[n
] < d2
[n
]) return (-1);
4826 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4828 const u32
*d1
= (const u32
*) v1
;
4829 const u32
*d2
= (const u32
*) v2
;
4835 if (d1
[n
] > d2
[n
]) return ( 1);
4836 if (d1
[n
] < d2
[n
]) return (-1);
4842 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4844 const u32
*d1
= (const u32
*) v1
;
4845 const u32
*d2
= (const u32
*) v2
;
4851 if (d1
[n
] > d2
[n
]) return ( 1);
4852 if (d1
[n
] < d2
[n
]) return (-1);
4858 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4860 const u32
*d1
= (const u32
*) v1
;
4861 const u32
*d2
= (const u32
*) v2
;
4867 if (d1
[n
] > d2
[n
]) return ( 1);
4868 if (d1
[n
] < d2
[n
]) return (-1);
4874 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4876 const u32
*d1
= (const u32
*) v1
;
4877 const u32
*d2
= (const u32
*) v2
;
4883 if (d1
[n
] > d2
[n
]) return ( 1);
4884 if (d1
[n
] < d2
[n
]) return (-1);
4890 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4892 const u32
*d1
= (const u32
*) v1
;
4893 const u32
*d2
= (const u32
*) v2
;
4899 if (d1
[n
] > d2
[n
]) return ( 1);
4900 if (d1
[n
] < d2
[n
]) return (-1);
4906 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4908 const u32
*d1
= (const u32
*) v1
;
4909 const u32
*d2
= (const u32
*) v2
;
4915 if (d1
[n
] > d2
[n
]) return ( 1);
4916 if (d1
[n
] < d2
[n
]) return (-1);
4922 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4924 const u32
*d1
= (const u32
*) v1
;
4925 const u32
*d2
= (const u32
*) v2
;
4931 if (d1
[n
] > d2
[n
]) return ( 1);
4932 if (d1
[n
] < d2
[n
]) return (-1);
4938 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4940 const u64
*d1
= (const u64
*) v1
;
4941 const u64
*d2
= (const u64
*) v2
;
4947 if (d1
[n
] > d2
[n
]) return ( 1);
4948 if (d1
[n
] < d2
[n
]) return (-1);
4954 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4956 const u64
*d1
= (const u64
*) v1
;
4957 const u64
*d2
= (const u64
*) v2
;
4963 if (d1
[n
] > d2
[n
]) return ( 1);
4964 if (d1
[n
] < d2
[n
]) return (-1);
4970 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4972 const u64
*d1
= (const u64
*) v1
;
4973 const u64
*d2
= (const u64
*) v2
;
4979 if (d1
[n
] > d2
[n
]) return ( 1);
4980 if (d1
[n
] < d2
[n
]) return (-1);
4986 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4988 const u32
*d1
= (const u32
*) v1
;
4989 const u32
*d2
= (const u32
*) v2
;
4991 const uint dgst_pos0
= data
.dgst_pos0
;
4992 const uint dgst_pos1
= data
.dgst_pos1
;
4993 const uint dgst_pos2
= data
.dgst_pos2
;
4994 const uint dgst_pos3
= data
.dgst_pos3
;
4996 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4997 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4998 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4999 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
5000 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
5001 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
5002 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
5003 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
5008 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
5010 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
5011 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
5013 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5015 if (res1
!= 0) return (res1
);
5020 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
5022 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
5023 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
5025 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
5027 if (res1
!= 0) return (res1
);
5029 const int res2
= t1
->attack_mode
5032 if (res2
!= 0) return (res2
);
5034 const int res3
= t1
->hash_type
5037 if (res3
!= 0) return (res3
);
5042 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
5044 uint outfile_autohex
= data
.outfile_autohex
;
5046 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
5048 FILE *debug_fp
= NULL
;
5050 if (debug_file
!= NULL
)
5052 debug_fp
= fopen (debug_file
, "ab");
5054 lock_file (debug_fp
);
5061 if (debug_fp
== NULL
)
5063 log_info ("WARNING: Could not open debug-file for writing");
5067 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
5069 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
5071 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
5074 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
5076 if (debug_mode
== 4)
5078 fputc (':', debug_fp
);
5080 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5083 fputc ('\n', debug_fp
);
5085 if (debug_file
!= NULL
) fclose (debug_fp
);
5089 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5091 int needs_hexify
= 0;
5093 if (outfile_autohex
== 1)
5095 for (uint i
= 0; i
< plain_len
; i
++)
5097 if (plain_ptr
[i
] < 0x20)
5104 if (plain_ptr
[i
] > 0x7f)
5113 if (needs_hexify
== 1)
5115 fprintf (fp
, "$HEX[");
5117 for (uint i
= 0; i
< plain_len
; i
++)
5119 fprintf (fp
, "%02x", plain_ptr
[i
]);
5126 fwrite (plain_ptr
, plain_len
, 1, fp
);
5130 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
5132 uint outfile_format
= data
.outfile_format
;
5134 char separator
= data
.separator
;
5136 if (outfile_format
& OUTFILE_FMT_HASH
)
5138 fprintf (out_fp
, "%s", out_buf
);
5140 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5142 fputc (separator
, out_fp
);
5145 else if (data
.username
)
5147 if (username
!= NULL
)
5149 for (uint i
= 0; i
< user_len
; i
++)
5151 fprintf (out_fp
, "%c", username
[i
]);
5154 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5156 fputc (separator
, out_fp
);
5161 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5163 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5165 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5167 fputc (separator
, out_fp
);
5171 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5173 for (uint i
= 0; i
< plain_len
; i
++)
5175 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5178 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5180 fputc (separator
, out_fp
);
5184 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5187 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5192 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5194 fprintf (out_fp
, "%llu", crackpos
);
5199 fputc ('\n', out_fp
);
5202 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5206 pot_key
.hash
.salt
= hashes_buf
->salt
;
5207 pot_key
.hash
.digest
= hashes_buf
->digest
;
5209 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5215 input_buf
[input_len
] = 0;
5218 unsigned char *username
= NULL
;
5223 user_t
*user
= hashes_buf
->hash_info
->user
;
5227 username
= (unsigned char *) (user
->user_name
);
5229 user_len
= user
->user_len
;
5233 // do output the line
5234 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5238 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5239 #define LM_MASKED_PLAIN "[notfound]"
5241 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5247 pot_left_key
.hash
.salt
= hash_left
->salt
;
5248 pot_left_key
.hash
.digest
= hash_left
->digest
;
5250 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5254 uint weak_hash_found
= 0;
5256 pot_t pot_right_key
;
5258 pot_right_key
.hash
.salt
= hash_right
->salt
;
5259 pot_right_key
.hash
.digest
= hash_right
->digest
;
5261 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5263 if (pot_right_ptr
== NULL
)
5265 // special case, if "weak hash"
5267 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5269 weak_hash_found
= 1;
5271 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5273 // in theory this is not needed, but we are paranoia:
5275 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5276 pot_right_ptr
->plain_len
= 0;
5280 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5282 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5287 // at least one half was found:
5291 input_buf
[input_len
] = 0;
5295 unsigned char *username
= NULL
;
5300 user_t
*user
= hash_left
->hash_info
->user
;
5304 username
= (unsigned char *) (user
->user_name
);
5306 user_len
= user
->user_len
;
5310 // mask the part which was not found
5312 uint left_part_masked
= 0;
5313 uint right_part_masked
= 0;
5315 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5317 if (pot_left_ptr
== NULL
)
5319 left_part_masked
= 1;
5321 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5323 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5325 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5326 pot_left_ptr
->plain_len
= mask_plain_len
;
5329 if (pot_right_ptr
== NULL
)
5331 right_part_masked
= 1;
5333 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5335 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5337 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5338 pot_right_ptr
->plain_len
= mask_plain_len
;
5341 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5345 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5347 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5349 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5351 // do output the line
5353 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5355 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5357 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5358 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5361 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5365 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5367 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5369 if (pot_ptr
== NULL
)
5373 input_buf
[input_len
] = 0;
5375 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5379 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5385 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5387 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5391 pot_t pot_right_key
;
5393 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5395 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5397 uint weak_hash_found
= 0;
5399 if (pot_right_ptr
== NULL
)
5401 // special case, if "weak hash"
5403 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5405 weak_hash_found
= 1;
5407 // we just need that pot_right_ptr is not a NULL pointer
5409 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5413 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5415 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5420 // ... at least one part was not cracked
5424 input_buf
[input_len
] = 0;
5426 // only show the hash part which is still not cracked
5428 uint user_len
= input_len
- 32;
5430 char *hash_output
= (char *) mymalloc (33);
5432 memcpy (hash_output
, input_buf
, input_len
);
5434 if (pot_left_ptr
!= NULL
)
5436 // only show right part (because left part was already found)
5438 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5440 hash_output
[user_len
+ 16] = 0;
5443 if (pot_right_ptr
!= NULL
)
5445 // only show left part (because right part was already found)
5447 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5449 hash_output
[user_len
+ 16] = 0;
5452 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5454 myfree (hash_output
);
5456 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5459 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5461 uint opencl_platforms_filter
= 0;
5463 if (opencl_platforms
)
5465 char *platforms
= strdup (opencl_platforms
);
5467 char *next
= strtok (platforms
, ",");
5471 int platform
= atoi (next
);
5473 if (platform
< 1 || platform
> 32)
5475 log_error ("ERROR: Invalid OpenCL platform %u specified", platform
);
5480 opencl_platforms_filter
|= 1 << (platform
- 1);
5482 } while ((next
= strtok (NULL
, ",")) != NULL
);
5488 opencl_platforms_filter
= -1;
5491 return opencl_platforms_filter
;
5494 u32
setup_devices_filter (char *opencl_devices
)
5496 u32 devices_filter
= 0;
5500 char *devices
= strdup (opencl_devices
);
5502 char *next
= strtok (devices
, ",");
5506 int device_id
= atoi (next
);
5508 if (device_id
< 1 || device_id
> 32)
5510 log_error ("ERROR: Invalid device_id %u specified", device_id
);
5515 devices_filter
|= 1 << (device_id
- 1);
5517 } while ((next
= strtok (NULL
, ",")) != NULL
);
5523 devices_filter
= -1;
5526 return devices_filter
;
5529 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5531 cl_device_type device_types_filter
= 0;
5533 if (opencl_device_types
)
5535 char *device_types
= strdup (opencl_device_types
);
5537 char *next
= strtok (device_types
, ",");
5541 int device_type
= atoi (next
);
5543 if (device_type
< 1 || device_type
> 3)
5545 log_error ("ERROR: Invalid device_type %u specified", device_type
);
5550 device_types_filter
|= 1 << device_type
;
5552 } while ((next
= strtok (NULL
, ",")) != NULL
);
5554 free (device_types
);
5558 // Do not use CPU by default, this often reduces GPU performance because
5559 // the CPU is too busy to handle GPU synchronization
5561 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5564 return device_types_filter
;
5567 u32
get_random_num (const u32 min
, const u32 max
)
5569 if (min
== max
) return (min
);
5571 return ((rand () % (max
- min
)) + min
);
5574 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5576 u32 quotient
= dividend
/ divisor
;
5578 if (dividend
% divisor
) quotient
++;
5583 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5585 u64 quotient
= dividend
/ divisor
;
5587 if (dividend
% divisor
) quotient
++;
5592 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5594 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5595 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5597 if (tm
->tm_year
- 70)
5599 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5600 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5602 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5604 else if (tm
->tm_yday
)
5606 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5607 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5609 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5611 else if (tm
->tm_hour
)
5613 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5614 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5616 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5618 else if (tm
->tm_min
)
5620 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5621 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5623 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5627 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5629 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5633 void format_speed_display (float val
, char *buf
, size_t len
)
5644 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5655 /* generate output */
5659 snprintf (buf
, len
- 1, "%.0f ", val
);
5663 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5667 void lowercase (u8
*buf
, int len
)
5669 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5672 void uppercase (u8
*buf
, int len
)
5674 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5677 int fgetl (FILE *fp
, char *line_buf
)
5683 const int c
= fgetc (fp
);
5685 if (c
== EOF
) break;
5687 line_buf
[line_len
] = (char) c
;
5691 if (line_len
== HCBUFSIZ
) line_len
--;
5693 if (c
== '\n') break;
5696 if (line_len
== 0) return 0;
5698 if (line_buf
[line_len
- 1] == '\n')
5702 line_buf
[line_len
] = 0;
5705 if (line_len
== 0) return 0;
5707 if (line_buf
[line_len
- 1] == '\r')
5711 line_buf
[line_len
] = 0;
5717 int in_superchop (char *buf
)
5719 int len
= strlen (buf
);
5723 if (buf
[len
- 1] == '\n')
5730 if (buf
[len
- 1] == '\r')
5745 char **scan_directory (const char *path
)
5747 char *tmp_path
= mystrdup (path
);
5749 size_t tmp_path_len
= strlen (tmp_path
);
5751 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5753 tmp_path
[tmp_path_len
- 1] = 0;
5755 tmp_path_len
= strlen (tmp_path
);
5758 char **files
= NULL
;
5764 if ((d
= opendir (tmp_path
)) != NULL
)
5770 memset (&e
, 0, sizeof (e
));
5771 struct dirent
*de
= NULL
;
5773 if (readdir_r (d
, &e
, &de
) != 0)
5775 log_error ("ERROR: readdir_r() failed");
5780 if (de
== NULL
) break;
5784 while ((de
= readdir (d
)) != NULL
)
5787 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5789 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5791 char *path_file
= (char *) mymalloc (path_size
+ 1);
5793 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5795 path_file
[path_size
] = 0;
5799 if ((d_test
= opendir (path_file
)) != NULL
)
5807 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5811 files
[num_files
- 1] = path_file
;
5817 else if (errno
== ENOTDIR
)
5819 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5823 files
[num_files
- 1] = mystrdup (path
);
5826 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5830 files
[num_files
- 1] = NULL
;
5837 int count_dictionaries (char **dictionary_files
)
5839 if (dictionary_files
== NULL
) return 0;
5843 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5851 char *stroptitype (const uint opti_type
)
5855 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5856 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5857 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5858 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5859 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5860 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5861 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5862 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5863 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5864 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5865 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5866 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5867 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5868 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5869 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5870 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5871 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5872 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5873 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5879 char *strparser (const uint parser_status
)
5881 switch (parser_status
)
5883 case PARSER_OK
: return ((char *) PA_000
); break;
5884 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5885 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5886 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5887 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5888 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5889 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5890 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5891 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5892 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5893 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5894 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5895 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5896 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5897 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5898 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5899 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5902 return ((char *) PA_255
);
5905 char *strhashtype (const uint hash_mode
)
5909 case 0: return ((char *) HT_00000
); break;
5910 case 10: return ((char *) HT_00010
); break;
5911 case 11: return ((char *) HT_00011
); break;
5912 case 12: return ((char *) HT_00012
); break;
5913 case 20: return ((char *) HT_00020
); break;
5914 case 21: return ((char *) HT_00021
); break;
5915 case 22: return ((char *) HT_00022
); break;
5916 case 23: return ((char *) HT_00023
); break;
5917 case 30: return ((char *) HT_00030
); break;
5918 case 40: return ((char *) HT_00040
); break;
5919 case 50: return ((char *) HT_00050
); break;
5920 case 60: return ((char *) HT_00060
); break;
5921 case 100: return ((char *) HT_00100
); break;
5922 case 101: return ((char *) HT_00101
); break;
5923 case 110: return ((char *) HT_00110
); break;
5924 case 111: return ((char *) HT_00111
); break;
5925 case 112: return ((char *) HT_00112
); break;
5926 case 120: return ((char *) HT_00120
); break;
5927 case 121: return ((char *) HT_00121
); break;
5928 case 122: return ((char *) HT_00122
); break;
5929 case 124: return ((char *) HT_00124
); break;
5930 case 125: return ((char *) HT_00125
); break;
5931 case 130: return ((char *) HT_00130
); break;
5932 case 131: return ((char *) HT_00131
); break;
5933 case 132: return ((char *) HT_00132
); break;
5934 case 133: return ((char *) HT_00133
); break;
5935 case 140: return ((char *) HT_00140
); break;
5936 case 141: return ((char *) HT_00141
); break;
5937 case 150: return ((char *) HT_00150
); break;
5938 case 160: return ((char *) HT_00160
); break;
5939 case 200: return ((char *) HT_00200
); break;
5940 case 300: return ((char *) HT_00300
); break;
5941 case 400: return ((char *) HT_00400
); break;
5942 case 500: return ((char *) HT_00500
); break;
5943 case 501: return ((char *) HT_00501
); break;
5944 case 900: return ((char *) HT_00900
); break;
5945 case 910: return ((char *) HT_00910
); break;
5946 case 1000: return ((char *) HT_01000
); break;
5947 case 1100: return ((char *) HT_01100
); break;
5948 case 1400: return ((char *) HT_01400
); break;
5949 case 1410: return ((char *) HT_01410
); break;
5950 case 1420: return ((char *) HT_01420
); break;
5951 case 1421: return ((char *) HT_01421
); break;
5952 case 1430: return ((char *) HT_01430
); break;
5953 case 1440: return ((char *) HT_01440
); break;
5954 case 1441: return ((char *) HT_01441
); break;
5955 case 1450: return ((char *) HT_01450
); break;
5956 case 1460: return ((char *) HT_01460
); break;
5957 case 1500: return ((char *) HT_01500
); break;
5958 case 1600: return ((char *) HT_01600
); break;
5959 case 1700: return ((char *) HT_01700
); break;
5960 case 1710: return ((char *) HT_01710
); break;
5961 case 1711: return ((char *) HT_01711
); break;
5962 case 1720: return ((char *) HT_01720
); break;
5963 case 1722: return ((char *) HT_01722
); break;
5964 case 1730: return ((char *) HT_01730
); break;
5965 case 1731: return ((char *) HT_01731
); break;
5966 case 1740: return ((char *) HT_01740
); break;
5967 case 1750: return ((char *) HT_01750
); break;
5968 case 1760: return ((char *) HT_01760
); break;
5969 case 1800: return ((char *) HT_01800
); break;
5970 case 2100: return ((char *) HT_02100
); break;
5971 case 2400: return ((char *) HT_02400
); break;
5972 case 2410: return ((char *) HT_02410
); break;
5973 case 2500: return ((char *) HT_02500
); break;
5974 case 2600: return ((char *) HT_02600
); break;
5975 case 2611: return ((char *) HT_02611
); break;
5976 case 2612: return ((char *) HT_02612
); break;
5977 case 2711: return ((char *) HT_02711
); break;
5978 case 2811: return ((char *) HT_02811
); break;
5979 case 3000: return ((char *) HT_03000
); break;
5980 case 3100: return ((char *) HT_03100
); break;
5981 case 3200: return ((char *) HT_03200
); break;
5982 case 3710: return ((char *) HT_03710
); break;
5983 case 3711: return ((char *) HT_03711
); break;
5984 case 3800: return ((char *) HT_03800
); break;
5985 case 4300: return ((char *) HT_04300
); break;
5986 case 4400: return ((char *) HT_04400
); break;
5987 case 4500: return ((char *) HT_04500
); break;
5988 case 4700: return ((char *) HT_04700
); break;
5989 case 4800: return ((char *) HT_04800
); break;
5990 case 4900: return ((char *) HT_04900
); break;
5991 case 5000: return ((char *) HT_05000
); break;
5992 case 5100: return ((char *) HT_05100
); break;
5993 case 5200: return ((char *) HT_05200
); break;
5994 case 5300: return ((char *) HT_05300
); break;
5995 case 5400: return ((char *) HT_05400
); break;
5996 case 5500: return ((char *) HT_05500
); break;
5997 case 5600: return ((char *) HT_05600
); break;
5998 case 5700: return ((char *) HT_05700
); break;
5999 case 5800: return ((char *) HT_05800
); break;
6000 case 6000: return ((char *) HT_06000
); break;
6001 case 6100: return ((char *) HT_06100
); break;
6002 case 6211: return ((char *) HT_06211
); break;
6003 case 6212: return ((char *) HT_06212
); break;
6004 case 6213: return ((char *) HT_06213
); break;
6005 case 6221: return ((char *) HT_06221
); break;
6006 case 6222: return ((char *) HT_06222
); break;
6007 case 6223: return ((char *) HT_06223
); break;
6008 case 6231: return ((char *) HT_06231
); break;
6009 case 6232: return ((char *) HT_06232
); break;
6010 case 6233: return ((char *) HT_06233
); break;
6011 case 6241: return ((char *) HT_06241
); break;
6012 case 6242: return ((char *) HT_06242
); break;
6013 case 6243: return ((char *) HT_06243
); break;
6014 case 6300: return ((char *) HT_06300
); break;
6015 case 6400: return ((char *) HT_06400
); break;
6016 case 6500: return ((char *) HT_06500
); break;
6017 case 6600: return ((char *) HT_06600
); break;
6018 case 6700: return ((char *) HT_06700
); break;
6019 case 6800: return ((char *) HT_06800
); break;
6020 case 6900: return ((char *) HT_06900
); break;
6021 case 7100: return ((char *) HT_07100
); break;
6022 case 7200: return ((char *) HT_07200
); break;
6023 case 7300: return ((char *) HT_07300
); break;
6024 case 7400: return ((char *) HT_07400
); break;
6025 case 7500: return ((char *) HT_07500
); break;
6026 case 7600: return ((char *) HT_07600
); break;
6027 case 7700: return ((char *) HT_07700
); break;
6028 case 7800: return ((char *) HT_07800
); break;
6029 case 7900: return ((char *) HT_07900
); break;
6030 case 8000: return ((char *) HT_08000
); break;
6031 case 8100: return ((char *) HT_08100
); break;
6032 case 8200: return ((char *) HT_08200
); break;
6033 case 8300: return ((char *) HT_08300
); break;
6034 case 8400: return ((char *) HT_08400
); break;
6035 case 8500: return ((char *) HT_08500
); break;
6036 case 8600: return ((char *) HT_08600
); break;
6037 case 8700: return ((char *) HT_08700
); break;
6038 case 8800: return ((char *) HT_08800
); break;
6039 case 8900: return ((char *) HT_08900
); break;
6040 case 9000: return ((char *) HT_09000
); break;
6041 case 9100: return ((char *) HT_09100
); break;
6042 case 9200: return ((char *) HT_09200
); break;
6043 case 9300: return ((char *) HT_09300
); break;
6044 case 9400: return ((char *) HT_09400
); break;
6045 case 9500: return ((char *) HT_09500
); break;
6046 case 9600: return ((char *) HT_09600
); break;
6047 case 9700: return ((char *) HT_09700
); break;
6048 case 9710: return ((char *) HT_09710
); break;
6049 case 9720: return ((char *) HT_09720
); break;
6050 case 9800: return ((char *) HT_09800
); break;
6051 case 9810: return ((char *) HT_09810
); break;
6052 case 9820: return ((char *) HT_09820
); break;
6053 case 9900: return ((char *) HT_09900
); break;
6054 case 10000: return ((char *) HT_10000
); break;
6055 case 10100: return ((char *) HT_10100
); break;
6056 case 10200: return ((char *) HT_10200
); break;
6057 case 10300: return ((char *) HT_10300
); break;
6058 case 10400: return ((char *) HT_10400
); break;
6059 case 10410: return ((char *) HT_10410
); break;
6060 case 10420: return ((char *) HT_10420
); break;
6061 case 10500: return ((char *) HT_10500
); break;
6062 case 10600: return ((char *) HT_10600
); break;
6063 case 10700: return ((char *) HT_10700
); break;
6064 case 10800: return ((char *) HT_10800
); break;
6065 case 10900: return ((char *) HT_10900
); break;
6066 case 11000: return ((char *) HT_11000
); break;
6067 case 11100: return ((char *) HT_11100
); break;
6068 case 11200: return ((char *) HT_11200
); break;
6069 case 11300: return ((char *) HT_11300
); break;
6070 case 11400: return ((char *) HT_11400
); break;
6071 case 11500: return ((char *) HT_11500
); break;
6072 case 11600: return ((char *) HT_11600
); break;
6073 case 11700: return ((char *) HT_11700
); break;
6074 case 11800: return ((char *) HT_11800
); break;
6075 case 11900: return ((char *) HT_11900
); break;
6076 case 12000: return ((char *) HT_12000
); break;
6077 case 12100: return ((char *) HT_12100
); break;
6078 case 12200: return ((char *) HT_12200
); break;
6079 case 12300: return ((char *) HT_12300
); break;
6080 case 12400: return ((char *) HT_12400
); break;
6081 case 12500: return ((char *) HT_12500
); break;
6082 case 12600: return ((char *) HT_12600
); break;
6083 case 12700: return ((char *) HT_12700
); break;
6084 case 12800: return ((char *) HT_12800
); break;
6085 case 12900: return ((char *) HT_12900
); break;
6086 case 13000: return ((char *) HT_13000
); break;
6087 case 13100: return ((char *) HT_13100
); break;
6088 case 13200: return ((char *) HT_13200
); break;
6089 case 13300: return ((char *) HT_13300
); break;
6090 case 13400: return ((char *) HT_13400
); break;
6091 case 13500: return ((char *) HT_13500
); break;
6092 case 13600: return ((char *) HT_13600
); break;
6093 case 13711: return ((char *) HT_13711
); break;
6094 case 13712: return ((char *) HT_13712
); break;
6095 case 13713: return ((char *) HT_13713
); break;
6096 case 13721: return ((char *) HT_13721
); break;
6097 case 13722: return ((char *) HT_13722
); break;
6098 case 13723: return ((char *) HT_13723
); break;
6099 case 13731: return ((char *) HT_13731
); break;
6100 case 13732: return ((char *) HT_13732
); break;
6101 case 13733: return ((char *) HT_13733
); break;
6102 case 13741: return ((char *) HT_13741
); break;
6103 case 13742: return ((char *) HT_13742
); break;
6104 case 13743: return ((char *) HT_13743
); break;
6105 case 13751: return ((char *) HT_13751
); break;
6106 case 13752: return ((char *) HT_13752
); break;
6107 case 13753: return ((char *) HT_13753
); break;
6108 case 13761: return ((char *) HT_13761
); break;
6109 case 13762: return ((char *) HT_13762
); break;
6110 case 13763: return ((char *) HT_13763
); break;
6111 case 13800: return ((char *) HT_13800
); break;
6114 return ((char *) "Unknown");
6117 char *strstatus (const uint devices_status
)
6119 switch (devices_status
)
6121 case STATUS_INIT
: return ((char *) ST_0000
); break;
6122 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6123 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6124 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6125 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6126 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6127 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6128 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6129 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6130 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6131 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6134 return ((char *) "Unknown");
6137 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6139 uint hash_type
= data
.hash_type
;
6140 uint hash_mode
= data
.hash_mode
;
6141 uint salt_type
= data
.salt_type
;
6142 uint opts_type
= data
.opts_type
;
6143 uint opti_type
= data
.opti_type
;
6144 uint dgst_size
= data
.dgst_size
;
6146 char *hashfile
= data
.hashfile
;
6150 uint digest_buf
[64] = { 0 };
6152 u64
*digest_buf64
= (u64
*) digest_buf
;
6154 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6156 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6158 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6164 case HASH_TYPE_DESCRYPT
:
6165 FP (digest_buf
[1], digest_buf
[0], tt
);
6168 case HASH_TYPE_DESRACF
:
6169 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6170 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6172 FP (digest_buf
[1], digest_buf
[0], tt
);
6176 FP (digest_buf
[1], digest_buf
[0], tt
);
6179 case HASH_TYPE_NETNTLM
:
6180 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6181 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6182 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6183 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6185 FP (digest_buf
[1], digest_buf
[0], tt
);
6186 FP (digest_buf
[3], digest_buf
[2], tt
);
6189 case HASH_TYPE_BSDICRYPT
:
6190 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6191 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6193 FP (digest_buf
[1], digest_buf
[0], tt
);
6198 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6203 digest_buf
[0] += MD4M_A
;
6204 digest_buf
[1] += MD4M_B
;
6205 digest_buf
[2] += MD4M_C
;
6206 digest_buf
[3] += MD4M_D
;
6210 digest_buf
[0] += MD5M_A
;
6211 digest_buf
[1] += MD5M_B
;
6212 digest_buf
[2] += MD5M_C
;
6213 digest_buf
[3] += MD5M_D
;
6216 case HASH_TYPE_SHA1
:
6217 digest_buf
[0] += SHA1M_A
;
6218 digest_buf
[1] += SHA1M_B
;
6219 digest_buf
[2] += SHA1M_C
;
6220 digest_buf
[3] += SHA1M_D
;
6221 digest_buf
[4] += SHA1M_E
;
6224 case HASH_TYPE_SHA256
:
6225 digest_buf
[0] += SHA256M_A
;
6226 digest_buf
[1] += SHA256M_B
;
6227 digest_buf
[2] += SHA256M_C
;
6228 digest_buf
[3] += SHA256M_D
;
6229 digest_buf
[4] += SHA256M_E
;
6230 digest_buf
[5] += SHA256M_F
;
6231 digest_buf
[6] += SHA256M_G
;
6232 digest_buf
[7] += SHA256M_H
;
6235 case HASH_TYPE_SHA384
:
6236 digest_buf64
[0] += SHA384M_A
;
6237 digest_buf64
[1] += SHA384M_B
;
6238 digest_buf64
[2] += SHA384M_C
;
6239 digest_buf64
[3] += SHA384M_D
;
6240 digest_buf64
[4] += SHA384M_E
;
6241 digest_buf64
[5] += SHA384M_F
;
6242 digest_buf64
[6] += 0;
6243 digest_buf64
[7] += 0;
6246 case HASH_TYPE_SHA512
:
6247 digest_buf64
[0] += SHA512M_A
;
6248 digest_buf64
[1] += SHA512M_B
;
6249 digest_buf64
[2] += SHA512M_C
;
6250 digest_buf64
[3] += SHA512M_D
;
6251 digest_buf64
[4] += SHA512M_E
;
6252 digest_buf64
[5] += SHA512M_F
;
6253 digest_buf64
[6] += SHA512M_G
;
6254 digest_buf64
[7] += SHA512M_H
;
6259 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6261 if (dgst_size
== DGST_SIZE_4_2
)
6263 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6265 else if (dgst_size
== DGST_SIZE_4_4
)
6267 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6269 else if (dgst_size
== DGST_SIZE_4_5
)
6271 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6273 else if (dgst_size
== DGST_SIZE_4_6
)
6275 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6277 else if (dgst_size
== DGST_SIZE_4_8
)
6279 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6281 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6283 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6285 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6287 else if (hash_type
== HASH_TYPE_SHA384
)
6289 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6291 else if (hash_type
== HASH_TYPE_SHA512
)
6293 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6295 else if (hash_type
== HASH_TYPE_GOST
)
6297 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6300 else if (dgst_size
== DGST_SIZE_4_64
)
6302 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6304 else if (dgst_size
== DGST_SIZE_8_25
)
6306 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6310 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6311 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6312 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6318 memset (&salt
, 0, sizeof (salt_t
));
6320 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6322 char *ptr
= (char *) salt
.salt_buf
;
6324 uint len
= salt
.salt_len
;
6326 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6332 case HASH_TYPE_NETNTLM
:
6334 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6335 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6337 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6343 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6345 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6353 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6355 uint max
= salt
.salt_len
/ 4;
6359 for (uint i
= 0; i
< max
; i
++)
6361 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6365 if (opts_type
& OPTS_TYPE_ST_HEX
)
6367 char tmp
[64] = { 0 };
6369 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6371 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6376 memcpy (ptr
, tmp
, len
);
6379 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6381 memset (ptr
+ len
, 0, memset_size
);
6383 salt
.salt_len
= len
;
6387 // some modes require special encoding
6390 uint out_buf_plain
[256] = { 0 };
6391 uint out_buf_salt
[256] = { 0 };
6393 char tmp_buf
[1024] = { 0 };
6395 char *ptr_plain
= (char *) out_buf_plain
;
6396 char *ptr_salt
= (char *) out_buf_salt
;
6398 if (hash_mode
== 22)
6400 char username
[30] = { 0 };
6402 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6404 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6406 u16
*ptr
= (u16
*) digest_buf
;
6408 tmp_buf
[ 0] = sig
[0];
6409 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6410 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6411 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6412 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6413 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6414 tmp_buf
[ 6] = sig
[1];
6415 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6416 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6417 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6418 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6419 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6420 tmp_buf
[12] = sig
[2];
6421 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6422 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6423 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6424 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6425 tmp_buf
[17] = sig
[3];
6426 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6427 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6428 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6429 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6430 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6431 tmp_buf
[23] = sig
[4];
6432 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6433 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6434 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6435 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6436 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6437 tmp_buf
[29] = sig
[5];
6439 snprintf (out_buf
, len
-1, "%s:%s",
6443 else if (hash_mode
== 23)
6445 // do not show the skyper part in output
6447 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6449 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6451 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6458 else if (hash_mode
== 101)
6460 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6462 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6463 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6464 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6465 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6466 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6468 memcpy (tmp_buf
, digest_buf
, 20);
6470 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6472 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6474 else if (hash_mode
== 111)
6476 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6478 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6479 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6480 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6481 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6482 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6484 memcpy (tmp_buf
, digest_buf
, 20);
6485 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6487 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6489 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6491 else if ((hash_mode
== 122) || (hash_mode
== 125))
6493 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6494 (char *) salt
.salt_buf
,
6501 else if (hash_mode
== 124)
6503 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6504 (char *) salt
.salt_buf
,
6511 else if (hash_mode
== 131)
6513 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6514 (char *) salt
.salt_buf
,
6522 else if (hash_mode
== 132)
6524 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6525 (char *) salt
.salt_buf
,
6532 else if (hash_mode
== 133)
6534 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6536 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6537 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6538 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6539 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6540 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6542 memcpy (tmp_buf
, digest_buf
, 20);
6544 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6546 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6548 else if (hash_mode
== 141)
6550 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6552 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6554 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6556 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6558 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6559 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6560 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6561 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6562 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6564 memcpy (tmp_buf
, digest_buf
, 20);
6566 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6570 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6572 else if (hash_mode
== 400)
6574 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6576 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6577 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6578 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6579 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6581 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6583 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6585 else if (hash_mode
== 500)
6587 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6589 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6590 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6591 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6592 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6594 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6596 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6598 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6602 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6605 else if (hash_mode
== 501)
6607 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6609 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6610 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6612 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6614 else if (hash_mode
== 1421)
6616 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6618 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6634 else if (hash_mode
== 1441)
6636 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6638 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6640 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6642 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6644 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6645 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6646 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6647 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6648 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6649 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6650 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6651 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6653 memcpy (tmp_buf
, digest_buf
, 32);
6655 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6659 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6661 else if (hash_mode
== 1500)
6663 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6664 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6665 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6666 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6667 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6669 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6671 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6673 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6674 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6676 memcpy (tmp_buf
, digest_buf
, 8);
6678 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6680 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6684 else if (hash_mode
== 1600)
6686 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6688 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6689 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6690 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6691 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6693 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6695 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6697 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6701 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6704 else if (hash_mode
== 1711)
6706 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6708 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6709 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6710 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6711 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6712 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6713 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6714 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6715 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6717 memcpy (tmp_buf
, digest_buf
, 64);
6718 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6720 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6722 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6724 else if (hash_mode
== 1722)
6726 uint
*ptr
= digest_buf
;
6728 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6729 (unsigned char *) salt
.salt_buf
,
6739 else if (hash_mode
== 1731)
6741 uint
*ptr
= digest_buf
;
6743 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6744 (unsigned char *) salt
.salt_buf
,
6754 else if (hash_mode
== 1800)
6758 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6759 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6760 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6761 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6762 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6763 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6764 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6765 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6767 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6769 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6771 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6775 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6778 else if (hash_mode
== 2100)
6782 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6784 salt
.salt_iter
+ 1);
6786 uint signature_len
= strlen (out_buf
);
6788 pos
+= signature_len
;
6789 len
-= signature_len
;
6791 char *salt_ptr
= (char *) salt
.salt_buf
;
6793 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6795 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6796 byte_swap_32 (digest_buf
[0]),
6797 byte_swap_32 (digest_buf
[1]),
6798 byte_swap_32 (digest_buf
[2]),
6799 byte_swap_32 (digest_buf
[3]));
6801 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6803 memcpy (tmp_buf
, digest_buf
, 16);
6805 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6807 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6808 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6809 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6810 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6812 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6813 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6814 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6815 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6817 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6818 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6819 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6820 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6822 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6823 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6824 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6825 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6827 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6828 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6829 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6830 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6834 else if (hash_mode
== 2500)
6836 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6838 wpa_t
*wpa
= &wpas
[salt_pos
];
6840 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6841 (char *) salt
.salt_buf
,
6855 else if (hash_mode
== 4400)
6857 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6858 byte_swap_32 (digest_buf
[0]),
6859 byte_swap_32 (digest_buf
[1]),
6860 byte_swap_32 (digest_buf
[2]),
6861 byte_swap_32 (digest_buf
[3]));
6863 else if (hash_mode
== 4700)
6865 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6866 byte_swap_32 (digest_buf
[0]),
6867 byte_swap_32 (digest_buf
[1]),
6868 byte_swap_32 (digest_buf
[2]),
6869 byte_swap_32 (digest_buf
[3]),
6870 byte_swap_32 (digest_buf
[4]));
6872 else if (hash_mode
== 4800)
6874 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6876 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6881 byte_swap_32 (salt
.salt_buf
[0]),
6882 byte_swap_32 (salt
.salt_buf
[1]),
6883 byte_swap_32 (salt
.salt_buf
[2]),
6884 byte_swap_32 (salt
.salt_buf
[3]),
6887 else if (hash_mode
== 4900)
6889 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6890 byte_swap_32 (digest_buf
[0]),
6891 byte_swap_32 (digest_buf
[1]),
6892 byte_swap_32 (digest_buf
[2]),
6893 byte_swap_32 (digest_buf
[3]),
6894 byte_swap_32 (digest_buf
[4]));
6896 else if (hash_mode
== 5100)
6898 snprintf (out_buf
, len
-1, "%08x%08x",
6902 else if (hash_mode
== 5200)
6904 snprintf (out_buf
, len
-1, "%s", hashfile
);
6906 else if (hash_mode
== 5300)
6908 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6910 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6912 int buf_len
= len
-1;
6916 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6918 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6920 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6922 snprintf (out_buf
, buf_len
, ":");
6928 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6936 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6938 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6940 if ((i
== 0) || (i
== 5))
6942 snprintf (out_buf
, buf_len
, ":");
6948 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6956 for (uint i
= 0; i
< 4; i
++)
6960 snprintf (out_buf
, buf_len
, ":");
6966 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6972 else if (hash_mode
== 5400)
6974 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6976 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6978 int buf_len
= len
-1;
6982 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6984 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6986 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6988 snprintf (out_buf
, buf_len
, ":");
6994 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
7002 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
7004 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
7006 if ((i
== 0) || (i
== 5))
7008 snprintf (out_buf
, buf_len
, ":");
7014 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
7022 for (uint i
= 0; i
< 5; i
++)
7026 snprintf (out_buf
, buf_len
, ":");
7032 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
7038 else if (hash_mode
== 5500)
7040 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7042 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7044 char user_buf
[64] = { 0 };
7045 char domain_buf
[64] = { 0 };
7046 char srvchall_buf
[1024] = { 0 };
7047 char clichall_buf
[1024] = { 0 };
7049 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7051 char *ptr
= (char *) netntlm
->userdomain_buf
;
7053 user_buf
[i
] = ptr
[j
];
7056 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7058 char *ptr
= (char *) netntlm
->userdomain_buf
;
7060 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7063 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7065 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7067 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7070 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7072 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7074 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7077 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7085 byte_swap_32 (salt
.salt_buf_pc
[0]),
7086 byte_swap_32 (salt
.salt_buf_pc
[1]),
7089 else if (hash_mode
== 5600)
7091 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7093 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7095 char user_buf
[64] = { 0 };
7096 char domain_buf
[64] = { 0 };
7097 char srvchall_buf
[1024] = { 0 };
7098 char clichall_buf
[1024] = { 0 };
7100 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7102 char *ptr
= (char *) netntlm
->userdomain_buf
;
7104 user_buf
[i
] = ptr
[j
];
7107 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7109 char *ptr
= (char *) netntlm
->userdomain_buf
;
7111 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7114 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7116 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7118 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7121 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7123 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7125 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7128 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7138 else if (hash_mode
== 5700)
7140 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7142 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7143 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7144 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7145 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7146 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7147 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7148 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7149 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7151 memcpy (tmp_buf
, digest_buf
, 32);
7153 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7157 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7159 else if (hash_mode
== 5800)
7161 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7162 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7163 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7164 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7165 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7167 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7174 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7176 snprintf (out_buf
, len
-1, "%s", hashfile
);
7178 else if (hash_mode
== 6300)
7180 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7182 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7183 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7184 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7185 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7187 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7189 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7191 else if (hash_mode
== 6400)
7193 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7195 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7197 else if (hash_mode
== 6500)
7199 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7201 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7203 else if (hash_mode
== 6600)
7205 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7207 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7209 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7210 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7212 uint buf_len
= len
- 1;
7214 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7217 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7219 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7224 else if (hash_mode
== 6700)
7226 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7228 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7230 else if (hash_mode
== 6800)
7232 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7234 else if (hash_mode
== 7100)
7236 uint
*ptr
= digest_buf
;
7238 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7240 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7242 uint esalt
[8] = { 0 };
7244 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7245 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7246 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7247 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7248 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7249 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7250 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7251 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7253 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7254 SIGNATURE_SHA512OSX
,
7256 esalt
[ 0], esalt
[ 1],
7257 esalt
[ 2], esalt
[ 3],
7258 esalt
[ 4], esalt
[ 5],
7259 esalt
[ 6], esalt
[ 7],
7267 ptr
[15], ptr
[14]);
7269 else if (hash_mode
== 7200)
7271 uint
*ptr
= digest_buf
;
7273 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7275 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7279 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7281 len_used
= strlen (out_buf
);
7283 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7285 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7287 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7290 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7298 ptr
[15], ptr
[14]);
7300 else if (hash_mode
== 7300)
7302 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7304 rakp_t
*rakp
= &rakps
[salt_pos
];
7306 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7308 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7311 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7318 else if (hash_mode
== 7400)
7320 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7322 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7323 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7324 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7325 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7326 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7327 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7328 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7329 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7331 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7333 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7335 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7339 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7342 else if (hash_mode
== 7500)
7344 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7346 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7348 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7349 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7351 char data
[128] = { 0 };
7353 char *ptr_data
= data
;
7355 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7357 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7360 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7362 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7367 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7369 (char *) krb5pa
->user
,
7370 (char *) krb5pa
->realm
,
7371 (char *) krb5pa
->salt
,
7374 else if (hash_mode
== 7700)
7376 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7377 (char *) salt
.salt_buf
,
7381 else if (hash_mode
== 7800)
7383 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7384 (char *) salt
.salt_buf
,
7391 else if (hash_mode
== 7900)
7393 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7397 char *tmp
= (char *) salt
.salt_buf_pc
;
7399 ptr_plain
[42] = tmp
[0];
7405 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7407 else if (hash_mode
== 8000)
7409 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7410 (unsigned char *) salt
.salt_buf
,
7420 else if (hash_mode
== 8100)
7422 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7423 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7425 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7426 (unsigned char *) salt
.salt_buf
,
7433 else if (hash_mode
== 8200)
7435 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7437 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7439 char data_buf
[4096] = { 0 };
7441 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7443 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7446 data_buf
[cloudkey
->data_len
* 2] = 0;
7448 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7449 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7450 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7451 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7452 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7453 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7454 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7455 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7457 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7458 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7459 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7460 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7462 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7478 else if (hash_mode
== 8300)
7480 char digest_buf_c
[34] = { 0 };
7482 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7483 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7484 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7485 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7486 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7488 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7490 digest_buf_c
[32] = 0;
7494 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7496 char domain_buf_c
[33] = { 0 };
7498 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7500 for (uint i
= 0; i
< salt_pc_len
; i
++)
7502 const char next
= domain_buf_c
[i
];
7504 domain_buf_c
[i
] = '.';
7509 domain_buf_c
[salt_pc_len
] = 0;
7513 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7515 else if (hash_mode
== 8500)
7517 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7519 else if (hash_mode
== 2612)
7521 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7523 (char *) salt
.salt_buf
,
7529 else if (hash_mode
== 3711)
7531 char *salt_ptr
= (char *) salt
.salt_buf
;
7533 salt_ptr
[salt
.salt_len
- 1] = 0;
7535 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7536 SIGNATURE_MEDIAWIKI_B
,
7543 else if (hash_mode
== 8800)
7545 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7547 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7549 char tmp
[3073] = { 0 };
7551 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7553 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7558 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7559 SIGNATURE_ANDROIDFDE
,
7560 byte_swap_32 (salt
.salt_buf
[0]),
7561 byte_swap_32 (salt
.salt_buf
[1]),
7562 byte_swap_32 (salt
.salt_buf
[2]),
7563 byte_swap_32 (salt
.salt_buf
[3]),
7564 byte_swap_32 (digest_buf
[0]),
7565 byte_swap_32 (digest_buf
[1]),
7566 byte_swap_32 (digest_buf
[2]),
7567 byte_swap_32 (digest_buf
[3]),
7570 else if (hash_mode
== 8900)
7572 uint N
= salt
.scrypt_N
;
7573 uint r
= salt
.scrypt_r
;
7574 uint p
= salt
.scrypt_p
;
7576 char base64_salt
[32] = { 0 };
7578 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7580 memset (tmp_buf
, 0, 46);
7582 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7583 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7584 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7585 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7586 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7587 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7588 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7589 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7590 digest_buf
[8] = 0; // needed for base64_encode ()
7592 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7594 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7602 else if (hash_mode
== 9000)
7604 snprintf (out_buf
, len
-1, "%s", hashfile
);
7606 else if (hash_mode
== 9200)
7610 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7612 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7614 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7618 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7619 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7620 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7621 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7622 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7623 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7624 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7625 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7626 digest_buf
[8] = 0; // needed for base64_encode ()
7628 char tmp_buf
[64] = { 0 };
7630 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7631 tmp_buf
[43] = 0; // cut it here
7635 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7637 else if (hash_mode
== 9300)
7639 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7640 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7641 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7642 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7643 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7644 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7645 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7646 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7647 digest_buf
[8] = 0; // needed for base64_encode ()
7649 char tmp_buf
[64] = { 0 };
7651 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7652 tmp_buf
[43] = 0; // cut it here
7654 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7656 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7658 else if (hash_mode
== 9400)
7660 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7662 office2007_t
*office2007
= &office2007s
[salt_pos
];
7664 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7665 SIGNATURE_OFFICE2007
,
7668 office2007
->keySize
,
7674 office2007
->encryptedVerifier
[0],
7675 office2007
->encryptedVerifier
[1],
7676 office2007
->encryptedVerifier
[2],
7677 office2007
->encryptedVerifier
[3],
7678 office2007
->encryptedVerifierHash
[0],
7679 office2007
->encryptedVerifierHash
[1],
7680 office2007
->encryptedVerifierHash
[2],
7681 office2007
->encryptedVerifierHash
[3],
7682 office2007
->encryptedVerifierHash
[4]);
7684 else if (hash_mode
== 9500)
7686 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7688 office2010_t
*office2010
= &office2010s
[salt_pos
];
7690 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7696 office2010
->encryptedVerifier
[0],
7697 office2010
->encryptedVerifier
[1],
7698 office2010
->encryptedVerifier
[2],
7699 office2010
->encryptedVerifier
[3],
7700 office2010
->encryptedVerifierHash
[0],
7701 office2010
->encryptedVerifierHash
[1],
7702 office2010
->encryptedVerifierHash
[2],
7703 office2010
->encryptedVerifierHash
[3],
7704 office2010
->encryptedVerifierHash
[4],
7705 office2010
->encryptedVerifierHash
[5],
7706 office2010
->encryptedVerifierHash
[6],
7707 office2010
->encryptedVerifierHash
[7]);
7709 else if (hash_mode
== 9600)
7711 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7713 office2013_t
*office2013
= &office2013s
[salt_pos
];
7715 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7721 office2013
->encryptedVerifier
[0],
7722 office2013
->encryptedVerifier
[1],
7723 office2013
->encryptedVerifier
[2],
7724 office2013
->encryptedVerifier
[3],
7725 office2013
->encryptedVerifierHash
[0],
7726 office2013
->encryptedVerifierHash
[1],
7727 office2013
->encryptedVerifierHash
[2],
7728 office2013
->encryptedVerifierHash
[3],
7729 office2013
->encryptedVerifierHash
[4],
7730 office2013
->encryptedVerifierHash
[5],
7731 office2013
->encryptedVerifierHash
[6],
7732 office2013
->encryptedVerifierHash
[7]);
7734 else if (hash_mode
== 9700)
7736 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7738 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7740 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7741 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7742 byte_swap_32 (salt
.salt_buf
[0]),
7743 byte_swap_32 (salt
.salt_buf
[1]),
7744 byte_swap_32 (salt
.salt_buf
[2]),
7745 byte_swap_32 (salt
.salt_buf
[3]),
7746 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7747 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7748 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7749 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7750 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7751 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7752 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7753 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7755 else if (hash_mode
== 9710)
7757 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7759 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7761 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7762 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7763 byte_swap_32 (salt
.salt_buf
[0]),
7764 byte_swap_32 (salt
.salt_buf
[1]),
7765 byte_swap_32 (salt
.salt_buf
[2]),
7766 byte_swap_32 (salt
.salt_buf
[3]),
7767 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7768 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7769 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7770 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7771 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7772 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7773 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7774 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7776 else if (hash_mode
== 9720)
7778 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7780 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7782 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7784 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7785 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7786 byte_swap_32 (salt
.salt_buf
[0]),
7787 byte_swap_32 (salt
.salt_buf
[1]),
7788 byte_swap_32 (salt
.salt_buf
[2]),
7789 byte_swap_32 (salt
.salt_buf
[3]),
7790 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7791 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7792 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7793 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7794 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7795 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7796 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7797 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7804 else if (hash_mode
== 9800)
7806 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7808 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7810 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7811 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7816 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7817 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7818 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7819 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7820 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7821 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7822 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7823 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7824 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7826 else if (hash_mode
== 9810)
7828 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7830 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7832 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7833 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7838 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7839 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7840 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7841 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7842 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7843 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7844 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7845 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7846 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7848 else if (hash_mode
== 9820)
7850 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7852 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7854 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7856 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7857 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7862 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7863 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7864 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7865 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7866 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7867 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7868 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7869 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7870 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7877 else if (hash_mode
== 10000)
7881 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7883 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7885 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7889 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7890 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7891 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7892 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7893 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7894 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7895 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7896 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7897 digest_buf
[8] = 0; // needed for base64_encode ()
7899 char tmp_buf
[64] = { 0 };
7901 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7905 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7907 else if (hash_mode
== 10100)
7909 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7914 byte_swap_32 (salt
.salt_buf
[0]),
7915 byte_swap_32 (salt
.salt_buf
[1]),
7916 byte_swap_32 (salt
.salt_buf
[2]),
7917 byte_swap_32 (salt
.salt_buf
[3]));
7919 else if (hash_mode
== 10200)
7921 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7923 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7927 char challenge
[100] = { 0 };
7929 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7933 char tmp_buf
[100] = { 0 };
7935 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7936 (char *) cram_md5
->user
,
7942 char response
[100] = { 0 };
7944 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7946 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7948 else if (hash_mode
== 10300)
7950 char tmp_buf
[100] = { 0 };
7952 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7953 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7955 uint tmp_len
= 20 + salt
.salt_len
;
7959 char base64_encoded
[100] = { 0 };
7961 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7963 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7965 else if (hash_mode
== 10400)
7967 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7969 pdf_t
*pdf
= &pdfs
[salt_pos
];
7971 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7979 byte_swap_32 (pdf
->id_buf
[0]),
7980 byte_swap_32 (pdf
->id_buf
[1]),
7981 byte_swap_32 (pdf
->id_buf
[2]),
7982 byte_swap_32 (pdf
->id_buf
[3]),
7984 byte_swap_32 (pdf
->u_buf
[0]),
7985 byte_swap_32 (pdf
->u_buf
[1]),
7986 byte_swap_32 (pdf
->u_buf
[2]),
7987 byte_swap_32 (pdf
->u_buf
[3]),
7988 byte_swap_32 (pdf
->u_buf
[4]),
7989 byte_swap_32 (pdf
->u_buf
[5]),
7990 byte_swap_32 (pdf
->u_buf
[6]),
7991 byte_swap_32 (pdf
->u_buf
[7]),
7993 byte_swap_32 (pdf
->o_buf
[0]),
7994 byte_swap_32 (pdf
->o_buf
[1]),
7995 byte_swap_32 (pdf
->o_buf
[2]),
7996 byte_swap_32 (pdf
->o_buf
[3]),
7997 byte_swap_32 (pdf
->o_buf
[4]),
7998 byte_swap_32 (pdf
->o_buf
[5]),
7999 byte_swap_32 (pdf
->o_buf
[6]),
8000 byte_swap_32 (pdf
->o_buf
[7])
8003 else if (hash_mode
== 10410)
8005 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8007 pdf_t
*pdf
= &pdfs
[salt_pos
];
8009 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8017 byte_swap_32 (pdf
->id_buf
[0]),
8018 byte_swap_32 (pdf
->id_buf
[1]),
8019 byte_swap_32 (pdf
->id_buf
[2]),
8020 byte_swap_32 (pdf
->id_buf
[3]),
8022 byte_swap_32 (pdf
->u_buf
[0]),
8023 byte_swap_32 (pdf
->u_buf
[1]),
8024 byte_swap_32 (pdf
->u_buf
[2]),
8025 byte_swap_32 (pdf
->u_buf
[3]),
8026 byte_swap_32 (pdf
->u_buf
[4]),
8027 byte_swap_32 (pdf
->u_buf
[5]),
8028 byte_swap_32 (pdf
->u_buf
[6]),
8029 byte_swap_32 (pdf
->u_buf
[7]),
8031 byte_swap_32 (pdf
->o_buf
[0]),
8032 byte_swap_32 (pdf
->o_buf
[1]),
8033 byte_swap_32 (pdf
->o_buf
[2]),
8034 byte_swap_32 (pdf
->o_buf
[3]),
8035 byte_swap_32 (pdf
->o_buf
[4]),
8036 byte_swap_32 (pdf
->o_buf
[5]),
8037 byte_swap_32 (pdf
->o_buf
[6]),
8038 byte_swap_32 (pdf
->o_buf
[7])
8041 else if (hash_mode
== 10420)
8043 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8045 pdf_t
*pdf
= &pdfs
[salt_pos
];
8047 u8
*rc4key
= (u8
*) pdf
->rc4key
;
8049 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
8057 byte_swap_32 (pdf
->id_buf
[0]),
8058 byte_swap_32 (pdf
->id_buf
[1]),
8059 byte_swap_32 (pdf
->id_buf
[2]),
8060 byte_swap_32 (pdf
->id_buf
[3]),
8062 byte_swap_32 (pdf
->u_buf
[0]),
8063 byte_swap_32 (pdf
->u_buf
[1]),
8064 byte_swap_32 (pdf
->u_buf
[2]),
8065 byte_swap_32 (pdf
->u_buf
[3]),
8066 byte_swap_32 (pdf
->u_buf
[4]),
8067 byte_swap_32 (pdf
->u_buf
[5]),
8068 byte_swap_32 (pdf
->u_buf
[6]),
8069 byte_swap_32 (pdf
->u_buf
[7]),
8071 byte_swap_32 (pdf
->o_buf
[0]),
8072 byte_swap_32 (pdf
->o_buf
[1]),
8073 byte_swap_32 (pdf
->o_buf
[2]),
8074 byte_swap_32 (pdf
->o_buf
[3]),
8075 byte_swap_32 (pdf
->o_buf
[4]),
8076 byte_swap_32 (pdf
->o_buf
[5]),
8077 byte_swap_32 (pdf
->o_buf
[6]),
8078 byte_swap_32 (pdf
->o_buf
[7]),
8086 else if (hash_mode
== 10500)
8088 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8090 pdf_t
*pdf
= &pdfs
[salt_pos
];
8092 if (pdf
->id_len
== 32)
8094 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8102 byte_swap_32 (pdf
->id_buf
[0]),
8103 byte_swap_32 (pdf
->id_buf
[1]),
8104 byte_swap_32 (pdf
->id_buf
[2]),
8105 byte_swap_32 (pdf
->id_buf
[3]),
8106 byte_swap_32 (pdf
->id_buf
[4]),
8107 byte_swap_32 (pdf
->id_buf
[5]),
8108 byte_swap_32 (pdf
->id_buf
[6]),
8109 byte_swap_32 (pdf
->id_buf
[7]),
8111 byte_swap_32 (pdf
->u_buf
[0]),
8112 byte_swap_32 (pdf
->u_buf
[1]),
8113 byte_swap_32 (pdf
->u_buf
[2]),
8114 byte_swap_32 (pdf
->u_buf
[3]),
8115 byte_swap_32 (pdf
->u_buf
[4]),
8116 byte_swap_32 (pdf
->u_buf
[5]),
8117 byte_swap_32 (pdf
->u_buf
[6]),
8118 byte_swap_32 (pdf
->u_buf
[7]),
8120 byte_swap_32 (pdf
->o_buf
[0]),
8121 byte_swap_32 (pdf
->o_buf
[1]),
8122 byte_swap_32 (pdf
->o_buf
[2]),
8123 byte_swap_32 (pdf
->o_buf
[3]),
8124 byte_swap_32 (pdf
->o_buf
[4]),
8125 byte_swap_32 (pdf
->o_buf
[5]),
8126 byte_swap_32 (pdf
->o_buf
[6]),
8127 byte_swap_32 (pdf
->o_buf
[7])
8132 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
8140 byte_swap_32 (pdf
->id_buf
[0]),
8141 byte_swap_32 (pdf
->id_buf
[1]),
8142 byte_swap_32 (pdf
->id_buf
[2]),
8143 byte_swap_32 (pdf
->id_buf
[3]),
8145 byte_swap_32 (pdf
->u_buf
[0]),
8146 byte_swap_32 (pdf
->u_buf
[1]),
8147 byte_swap_32 (pdf
->u_buf
[2]),
8148 byte_swap_32 (pdf
->u_buf
[3]),
8149 byte_swap_32 (pdf
->u_buf
[4]),
8150 byte_swap_32 (pdf
->u_buf
[5]),
8151 byte_swap_32 (pdf
->u_buf
[6]),
8152 byte_swap_32 (pdf
->u_buf
[7]),
8154 byte_swap_32 (pdf
->o_buf
[0]),
8155 byte_swap_32 (pdf
->o_buf
[1]),
8156 byte_swap_32 (pdf
->o_buf
[2]),
8157 byte_swap_32 (pdf
->o_buf
[3]),
8158 byte_swap_32 (pdf
->o_buf
[4]),
8159 byte_swap_32 (pdf
->o_buf
[5]),
8160 byte_swap_32 (pdf
->o_buf
[6]),
8161 byte_swap_32 (pdf
->o_buf
[7])
8165 else if (hash_mode
== 10600)
8167 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8169 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8170 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8172 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8174 else if (hash_mode
== 10700)
8176 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8178 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8179 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8181 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8183 else if (hash_mode
== 10900)
8185 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8187 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8188 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8190 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8192 else if (hash_mode
== 11100)
8194 u32 salt_challenge
= salt
.salt_buf
[0];
8196 salt_challenge
= byte_swap_32 (salt_challenge
);
8198 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8200 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8201 SIGNATURE_POSTGRESQL_AUTH
,
8209 else if (hash_mode
== 11200)
8211 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8212 SIGNATURE_MYSQL_AUTH
,
8213 (unsigned char *) salt
.salt_buf
,
8220 else if (hash_mode
== 11300)
8222 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8224 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8226 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8227 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8228 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8230 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8231 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8232 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8234 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8236 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8238 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8241 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8243 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8245 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8248 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8250 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8252 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8255 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8256 SIGNATURE_BITCOIN_WALLET
,
8260 (unsigned char *) salt
.salt_buf
,
8268 free (cry_master_buf
);
8270 free (public_key_buf
);
8272 else if (hash_mode
== 11400)
8274 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8276 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8277 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8279 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8281 else if (hash_mode
== 11600)
8283 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8285 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8287 const uint data_len
= seven_zip
->data_len
;
8289 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8291 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8293 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8295 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8298 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8299 SIGNATURE_SEVEN_ZIP
,
8303 (char *) seven_zip
->salt_buf
,
8305 seven_zip
->iv_buf
[0],
8306 seven_zip
->iv_buf
[1],
8307 seven_zip
->iv_buf
[2],
8308 seven_zip
->iv_buf
[3],
8310 seven_zip
->data_len
,
8311 seven_zip
->unpack_size
,
8316 else if (hash_mode
== 11700)
8318 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8328 else if (hash_mode
== 11800)
8330 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8348 else if (hash_mode
== 11900)
8350 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8352 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8353 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8355 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8357 else if (hash_mode
== 12000)
8359 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8361 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8362 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8364 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8366 else if (hash_mode
== 12100)
8368 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8370 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8371 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8373 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8375 else if (hash_mode
== 12200)
8377 uint
*ptr_digest
= digest_buf
;
8378 uint
*ptr_salt
= salt
.salt_buf
;
8380 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8387 else if (hash_mode
== 12300)
8389 uint
*ptr_digest
= digest_buf
;
8390 uint
*ptr_salt
= salt
.salt_buf
;
8392 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
8393 ptr_digest
[ 0], ptr_digest
[ 1],
8394 ptr_digest
[ 2], ptr_digest
[ 3],
8395 ptr_digest
[ 4], ptr_digest
[ 5],
8396 ptr_digest
[ 6], ptr_digest
[ 7],
8397 ptr_digest
[ 8], ptr_digest
[ 9],
8398 ptr_digest
[10], ptr_digest
[11],
8399 ptr_digest
[12], ptr_digest
[13],
8400 ptr_digest
[14], ptr_digest
[15],
8406 else if (hash_mode
== 12400)
8408 // encode iteration count
8410 char salt_iter
[5] = { 0 };
8412 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8413 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8414 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8415 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8420 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8421 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8422 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8423 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8428 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8430 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8431 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8433 memcpy (tmp_buf
, digest_buf
, 8);
8435 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8439 // fill the resulting buffer
8441 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8443 else if (hash_mode
== 12500)
8445 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8447 byte_swap_32 (salt
.salt_buf
[0]),
8448 byte_swap_32 (salt
.salt_buf
[1]),
8454 else if (hash_mode
== 12600)
8456 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8457 digest_buf
[0] + salt
.salt_buf_pc
[0],
8458 digest_buf
[1] + salt
.salt_buf_pc
[1],
8459 digest_buf
[2] + salt
.salt_buf_pc
[2],
8460 digest_buf
[3] + salt
.salt_buf_pc
[3],
8461 digest_buf
[4] + salt
.salt_buf_pc
[4],
8462 digest_buf
[5] + salt
.salt_buf_pc
[5],
8463 digest_buf
[6] + salt
.salt_buf_pc
[6],
8464 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8466 else if (hash_mode
== 12700)
8468 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8470 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8471 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8473 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8475 else if (hash_mode
== 12800)
8477 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8479 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8492 byte_swap_32 (digest_buf
[0]),
8493 byte_swap_32 (digest_buf
[1]),
8494 byte_swap_32 (digest_buf
[2]),
8495 byte_swap_32 (digest_buf
[3]),
8496 byte_swap_32 (digest_buf
[4]),
8497 byte_swap_32 (digest_buf
[5]),
8498 byte_swap_32 (digest_buf
[6]),
8499 byte_swap_32 (digest_buf
[7])
8502 else if (hash_mode
== 12900)
8504 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8513 byte_swap_32 (digest_buf
[0]),
8514 byte_swap_32 (digest_buf
[1]),
8515 byte_swap_32 (digest_buf
[2]),
8516 byte_swap_32 (digest_buf
[3]),
8517 byte_swap_32 (digest_buf
[4]),
8518 byte_swap_32 (digest_buf
[5]),
8519 byte_swap_32 (digest_buf
[6]),
8520 byte_swap_32 (digest_buf
[7]),
8527 else if (hash_mode
== 13000)
8529 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8531 rar5_t
*rar5
= &rar5s
[salt_pos
];
8533 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8543 byte_swap_32 (digest_buf
[0]),
8544 byte_swap_32 (digest_buf
[1])
8547 else if (hash_mode
== 13100)
8549 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8551 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8553 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8554 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8556 char data
[2560 * 4 * 2] = { 0 };
8558 char *ptr_data
= data
;
8560 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8561 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8566 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8567 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8569 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8571 (char *) krb5tgs
->account_info
,
8575 else if (hash_mode
== 13200)
8577 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8591 else if (hash_mode
== 13300)
8593 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8594 SIGNATURE_AXCRYPT_SHA1
,
8600 else if (hash_mode
== 13400)
8602 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8604 keepass_t
*keepass
= &keepasss
[salt_pos
];
8606 u32 version
= (u32
) keepass
->version
;
8607 u32 rounds
= salt
.salt_iter
;
8608 u32 algorithm
= (u32
) keepass
->algorithm
;
8609 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8611 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8612 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8613 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8614 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8615 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8617 /* specific to version 1 */
8621 /* specific to version 2 */
8622 u32 expected_bytes_len
;
8623 u32
*ptr_expected_bytes
;
8625 u32 final_random_seed_len
;
8626 u32 transf_random_seed_len
;
8628 u32 contents_hash_len
;
8630 transf_random_seed_len
= 8;
8632 contents_hash_len
= 8;
8633 final_random_seed_len
= 8;
8636 final_random_seed_len
= 4;
8638 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8644 char *ptr_data
= out_buf
;
8646 ptr_data
+= strlen(out_buf
);
8651 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8652 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8657 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8658 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8663 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8664 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8671 contents_len
= (u32
) keepass
->contents_len
;
8672 ptr_contents
= (u32
*) keepass
->contents
;
8674 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8675 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8687 char ptr_contents_len
[10] = { 0 };
8689 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8691 sprintf (ptr_data
, "%d", contents_len
);
8693 ptr_data
+= strlen(ptr_contents_len
);
8698 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8699 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8701 else if (version
== 2)
8703 expected_bytes_len
= 8;
8704 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8706 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8707 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8712 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8713 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8727 sprintf (ptr_data
, "%d", keyfile_len
);
8734 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8735 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8738 else if (hash_mode
== 13500)
8740 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8742 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8744 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8746 char pstoken_tmp
[1024 + 1] = { 0 };
8748 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8750 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8752 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8755 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8763 else if (hash_mode
== 13600)
8765 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8767 zip2_t
*zip2
= &zip2s
[salt_pos
];
8769 const u32 salt_len
= zip2
->salt_len
;
8771 char salt_tmp
[32 + 1] = { 0 };
8773 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8775 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8777 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8780 const u32 data_len
= zip2
->data_len
;
8782 char data_tmp
[8192 + 1] = { 0 };
8784 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8786 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8788 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8791 const u32 auth_len
= zip2
->auth_len
;
8793 char auth_tmp
[20 + 1] = { 0 };
8795 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8797 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8799 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8802 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8803 SIGNATURE_ZIP2_START
,
8809 zip2
->compress_length
,
8812 SIGNATURE_ZIP2_STOP
);
8814 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8816 snprintf (out_buf
, len
-1, "%s", hashfile
);
8818 else if (hash_mode
== 13800)
8820 win8phone_t
*esalts
= (win8phone_t
*) data
.esalts_buf
;
8822 win8phone_t
*esalt
= &esalts
[salt_pos
];
8824 char buf
[256 + 1] = { 0 };
8826 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
8828 sprintf (buf
+ j
, "%08x", esalt
->salt_buf
[i
]);
8831 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%s",
8844 if (hash_type
== HASH_TYPE_MD4
)
8846 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8852 else if (hash_type
== HASH_TYPE_MD5
)
8854 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8860 else if (hash_type
== HASH_TYPE_SHA1
)
8862 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8869 else if (hash_type
== HASH_TYPE_SHA256
)
8871 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8881 else if (hash_type
== HASH_TYPE_SHA384
)
8883 uint
*ptr
= digest_buf
;
8885 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8893 else if (hash_type
== HASH_TYPE_SHA512
)
8895 uint
*ptr
= digest_buf
;
8897 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8907 else if (hash_type
== HASH_TYPE_LM
)
8909 snprintf (out_buf
, len
-1, "%08x%08x",
8913 else if (hash_type
== HASH_TYPE_ORACLEH
)
8915 snprintf (out_buf
, len
-1, "%08X%08X",
8919 else if (hash_type
== HASH_TYPE_BCRYPT
)
8921 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8922 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8924 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8926 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8928 else if (hash_type
== HASH_TYPE_KECCAK
)
8930 uint
*ptr
= digest_buf
;
8932 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8960 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8962 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8964 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8971 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8973 digest_buf
[ 0] = digest_buf
[ 0];
8974 digest_buf
[ 1] = digest_buf
[ 1];
8975 digest_buf
[ 2] = digest_buf
[ 2];
8976 digest_buf
[ 3] = digest_buf
[ 3];
8977 digest_buf
[ 4] = digest_buf
[ 4];
8978 digest_buf
[ 5] = digest_buf
[ 5];
8979 digest_buf
[ 6] = digest_buf
[ 6];
8980 digest_buf
[ 7] = digest_buf
[ 7];
8981 digest_buf
[ 8] = digest_buf
[ 8];
8982 digest_buf
[ 9] = digest_buf
[ 9];
8983 digest_buf
[10] = digest_buf
[10];
8984 digest_buf
[11] = digest_buf
[11];
8985 digest_buf
[12] = digest_buf
[12];
8986 digest_buf
[13] = digest_buf
[13];
8987 digest_buf
[14] = digest_buf
[14];
8988 digest_buf
[15] = digest_buf
[15];
8990 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
9008 else if (hash_type
== HASH_TYPE_GOST
)
9010 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
9020 else if (hash_type
== HASH_TYPE_MYSQL
)
9022 snprintf (out_buf
, len
-1, "%08x%08x",
9026 else if (hash_type
== HASH_TYPE_LOTUS5
)
9028 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
9034 else if (hash_type
== HASH_TYPE_LOTUS6
)
9036 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
9037 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
9038 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
9039 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
9041 char buf
[16] = { 0 };
9043 memcpy (buf
+ 0, salt
.salt_buf
, 5);
9044 memcpy (buf
+ 5, digest_buf
, 9);
9048 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
9050 tmp_buf
[18] = salt
.salt_buf_pc
[7];
9053 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
9055 else if (hash_type
== HASH_TYPE_LOTUS8
)
9057 char buf
[52] = { 0 };
9061 memcpy (buf
+ 0, salt
.salt_buf
, 16);
9067 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
9071 buf
[26] = salt
.salt_buf_pc
[0];
9072 buf
[27] = salt
.salt_buf_pc
[1];
9076 memcpy (buf
+ 28, digest_buf
, 8);
9078 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
9082 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
9084 else if (hash_type
== HASH_TYPE_CRC32
)
9086 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
9090 if (salt_type
== SALT_TYPE_INTERN
)
9092 size_t pos
= strlen (out_buf
);
9094 out_buf
[pos
] = data
.separator
;
9096 char *ptr
= (char *) salt
.salt_buf
;
9098 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
9100 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9104 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9106 memset (hccap
, 0, sizeof (hccap_t
));
9108 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9110 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9112 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9113 wpa_t
*wpa
= &wpas
[salt_pos
];
9115 hccap
->keyver
= wpa
->keyver
;
9117 hccap
->eapol_size
= wpa
->eapol_size
;
9119 if (wpa
->keyver
!= 1)
9121 uint eapol_tmp
[64] = { 0 };
9123 for (uint i
= 0; i
< 64; i
++)
9125 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9128 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9132 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9135 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9136 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9137 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9138 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9140 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9142 uint dgst_size
= data
.dgst_size
;
9144 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9146 if (wpa
->keyver
!= 1)
9148 uint digest_tmp
[4] = { 0 };
9150 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9151 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9152 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9153 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9155 memcpy (hccap
->keymic
, digest_tmp
, 16);
9159 memcpy (hccap
->keymic
, digest_ptr
, 16);
9163 void SuspendThreads ()
9165 if (data
.devices_status
== STATUS_RUNNING
)
9167 hc_timer_set (&data
.timer_paused
);
9169 data
.devices_status
= STATUS_PAUSED
;
9171 log_info ("Paused");
9175 void ResumeThreads ()
9177 if (data
.devices_status
== STATUS_PAUSED
)
9181 hc_timer_get (data
.timer_paused
, ms_paused
);
9183 data
.ms_paused
+= ms_paused
;
9185 data
.devices_status
= STATUS_RUNNING
;
9187 log_info ("Resumed");
9193 if (data
.devices_status
!= STATUS_RUNNING
) return;
9195 data
.devices_status
= STATUS_BYPASS
;
9197 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9200 void stop_at_checkpoint ()
9202 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9204 if (data
.devices_status
!= STATUS_RUNNING
) return;
9207 // this feature only makes sense if --restore-disable was not specified
9209 if (data
.restore_disable
== 1)
9211 log_info ("WARNING: This feature is disabled when --restore-disable is specified");
9216 // check if monitoring of Restore Point updates should be enabled or disabled
9218 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9220 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9222 // save the current restore point value
9224 data
.checkpoint_cur_words
= get_lowest_words_done ();
9226 log_info ("Checkpoint enabled: Will quit at next Restore Point update");
9230 data
.devices_status
= STATUS_RUNNING
;
9232 // reset the global value for checkpoint checks
9234 data
.checkpoint_cur_words
= 0;
9236 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9242 //if (data.devices_status == STATUS_INIT) return;
9243 //if (data.devices_status == STATUS_STARTING) return;
9245 data
.devices_status
= STATUS_ABORTED
;
9250 //if (data.devices_status == STATUS_INIT) return;
9251 //if (data.devices_status == STATUS_STARTING) return;
9253 data
.devices_status
= STATUS_QUIT
;
9256 void naive_replace (char *s
, const u8 key_char
, const u8 replace_char
)
9258 const size_t len
= strlen (s
);
9260 for (size_t in
= 0; in
< len
; in
++)
9266 s
[in
] = replace_char
;
9271 void naive_escape (char *s
, size_t s_max
, const u8 key_char
, const u8 escape_char
)
9273 char s_escaped
[1024] = { 0 };
9275 size_t s_escaped_max
= sizeof (s_escaped
);
9277 const size_t len
= strlen (s
);
9279 for (size_t in
= 0, out
= 0; in
< len
; in
++, out
++)
9285 s_escaped
[out
] = escape_char
;
9290 if (out
== s_escaped_max
- 2) break;
9295 strncpy (s
, s_escaped
, s_max
- 1);
9298 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9300 FILE *fp
= fopen (kernel_file
, "rb");
9306 memset (&st
, 0, sizeof (st
));
9308 stat (kernel_file
, &st
);
9310 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9312 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9314 if (num_read
!= (size_t) st
.st_size
)
9316 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9323 buf
[st
.st_size
] = 0;
9325 for (int i
= 0; i
< num_devices
; i
++)
9327 kernel_lengths
[i
] = (size_t) st
.st_size
;
9329 kernel_sources
[i
] = buf
;
9334 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9342 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9344 if (binary_size
> 0)
9346 FILE *fp
= fopen (dst
, "wb");
9349 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9360 restore_data_t
*init_restore (int argc
, char **argv
)
9362 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9364 if (data
.restore_disable
== 0)
9366 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9370 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9374 log_error ("ERROR: Cannot read %s", data
.eff_restore_file
);
9383 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9385 int pidbin_len
= -1;
9388 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9390 FILE *fd
= fopen (pidbin
, "rb");
9394 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9396 pidbin
[pidbin_len
] = 0;
9400 char *argv0_r
= strrchr (argv
[0], '/');
9402 char *pidbin_r
= strrchr (pidbin
, '/');
9404 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9406 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9408 if (strcmp (argv0_r
, pidbin_r
) == 0)
9410 log_error ("ERROR: Already an instance %s running on pid %d", pidbin
, rd
->pid
);
9417 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9419 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9421 int pidbin2_len
= -1;
9423 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9424 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9426 pidbin
[pidbin_len
] = 0;
9427 pidbin2
[pidbin2_len
] = 0;
9431 if (strcmp (pidbin
, pidbin2
) == 0)
9433 log_error ("ERROR: Already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9446 if (rd
->version_bin
< RESTORE_MIN
)
9448 log_error ("ERROR: Cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9455 memset (rd
, 0, sizeof (restore_data_t
));
9457 rd
->version_bin
= VERSION_BIN
;
9460 rd
->pid
= getpid ();
9462 rd
->pid
= GetCurrentProcessId ();
9465 if (getcwd (rd
->cwd
, 255) == NULL
)
9478 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9480 FILE *fp
= fopen (eff_restore_file
, "rb");
9484 log_error ("ERROR: Restore file '%s': %s", eff_restore_file
, strerror (errno
));
9489 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9491 log_error ("ERROR: Can't read %s", eff_restore_file
);
9496 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9498 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9500 for (uint i
= 0; i
< rd
->argc
; i
++)
9502 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9504 log_error ("ERROR: Can't read %s", eff_restore_file
);
9509 size_t len
= strlen (buf
);
9511 if (len
) buf
[len
- 1] = 0;
9513 rd
->argv
[i
] = mystrdup (buf
);
9520 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9522 if (chdir (rd
->cwd
))
9524 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9525 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9526 " https://github.com/philsmd/analyze_hc_restore\n"
9527 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9533 u64
get_lowest_words_done ()
9537 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9539 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9541 if (device_param
->skipped
) continue;
9543 const u64 words_done
= device_param
->words_done
;
9545 if (words_done
< words_cur
) words_cur
= words_done
;
9548 // It's possible that a device's workload isn't finished right after a restore-case.
9549 // In that case, this function would return 0 and overwrite the real restore point
9550 // There's also data.words_cur which is set to rd->words_cur but it changes while
9551 // the attack is running therefore we should stick to rd->words_cur.
9552 // Note that -s influences rd->words_cur we should keep a close look on that.
9554 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9559 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9561 u64 words_cur
= get_lowest_words_done ();
9563 rd
->words_cur
= words_cur
;
9565 FILE *fp
= fopen (new_restore_file
, "wb");
9569 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9574 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9576 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9581 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9583 for (uint i
= 0; i
< rd
->argc
; i
++)
9585 fprintf (fp
, "%s", rd
->argv
[i
]);
9591 fsync (fileno (fp
));
9596 void cycle_restore ()
9598 const char *eff_restore_file
= data
.eff_restore_file
;
9599 const char *new_restore_file
= data
.new_restore_file
;
9601 restore_data_t
*rd
= data
.rd
;
9603 write_restore (new_restore_file
, rd
);
9607 memset (&st
, 0, sizeof(st
));
9609 if (stat (eff_restore_file
, &st
) == 0)
9611 if (unlink (eff_restore_file
))
9613 log_info ("WARN: Unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9617 if (rename (new_restore_file
, eff_restore_file
))
9619 log_info ("WARN: Rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9623 void check_checkpoint ()
9625 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9627 u64 words_cur
= get_lowest_words_done ();
9629 if (words_cur
!= data
.checkpoint_cur_words
)
9639 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9643 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9645 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9647 myfree (alias
->device_name
);
9648 myfree (alias
->alias_name
);
9651 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9653 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9655 myfree (entry
->device_name
);
9658 myfree (tuning_db
->alias_buf
);
9659 myfree (tuning_db
->entry_buf
);
9664 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9666 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9668 int num_lines
= count_lines (fp
);
9670 // a bit over-allocated
9672 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9673 tuning_db
->alias_cnt
= 0;
9675 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9676 tuning_db
->entry_cnt
= 0;
9681 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9683 FILE *fp
= fopen (tuning_db_file
, "rb");
9687 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9692 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9698 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9702 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9704 if (line_buf
== NULL
) break;
9708 const int line_len
= in_superchop (line_buf
);
9710 if (line_len
== 0) continue;
9712 if (line_buf
[0] == '#') continue;
9716 char *token_ptr
[7] = { NULL
};
9720 char *next
= strtok (line_buf
, "\t ");
9722 token_ptr
[token_cnt
] = next
;
9726 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9728 token_ptr
[token_cnt
] = next
;
9735 char *device_name
= token_ptr
[0];
9736 char *alias_name
= token_ptr
[1];
9738 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9740 alias
->device_name
= mystrdup (device_name
);
9741 alias
->alias_name
= mystrdup (alias_name
);
9743 tuning_db
->alias_cnt
++;
9745 else if (token_cnt
== 6)
9747 if ((token_ptr
[1][0] != '0') &&
9748 (token_ptr
[1][0] != '1') &&
9749 (token_ptr
[1][0] != '3') &&
9750 (token_ptr
[1][0] != '*'))
9752 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9757 if ((token_ptr
[3][0] != '1') &&
9758 (token_ptr
[3][0] != '2') &&
9759 (token_ptr
[3][0] != '4') &&
9760 (token_ptr
[3][0] != '8') &&
9761 (token_ptr
[3][0] != 'N'))
9763 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9768 char *device_name
= token_ptr
[0];
9770 int attack_mode
= -1;
9772 int vector_width
= -1;
9773 int kernel_accel
= -1;
9774 int kernel_loops
= -1;
9776 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9777 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9778 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9780 if (token_ptr
[4][0] != 'A')
9782 kernel_accel
= atoi (token_ptr
[4]);
9784 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9786 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9796 if (token_ptr
[5][0] != 'A')
9798 kernel_loops
= atoi (token_ptr
[5]);
9800 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9802 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9812 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9814 entry
->device_name
= mystrdup (device_name
);
9815 entry
->attack_mode
= attack_mode
;
9816 entry
->hash_type
= hash_type
;
9817 entry
->vector_width
= vector_width
;
9818 entry
->kernel_accel
= kernel_accel
;
9819 entry
->kernel_loops
= kernel_loops
;
9821 tuning_db
->entry_cnt
++;
9825 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9835 // todo: print loaded 'cnt' message
9837 // sort the database
9839 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9840 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9845 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9847 static tuning_db_entry_t s
;
9849 // first we need to convert all spaces in the device_name to underscore
9851 char *device_name_nospace
= strdup (device_param
->device_name
);
9853 int device_name_length
= strlen (device_name_nospace
);
9857 for (i
= 0; i
< device_name_length
; i
++)
9859 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9862 // find out if there's an alias configured
9864 tuning_db_alias_t a
;
9866 a
.device_name
= device_name_nospace
;
9868 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
);
9870 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9872 // attack-mode 6 and 7 are attack-mode 1 basically
9874 if (attack_mode
== 6) attack_mode
= 1;
9875 if (attack_mode
== 7) attack_mode
= 1;
9877 // bsearch is not ideal but fast enough
9879 s
.device_name
= device_name_nospace
;
9880 s
.attack_mode
= attack_mode
;
9881 s
.hash_type
= hash_type
;
9883 tuning_db_entry_t
*entry
= NULL
;
9885 // this will produce all 2^3 combinations required
9887 for (i
= 0; i
< 8; i
++)
9889 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9890 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9891 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9893 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9895 if (entry
!= NULL
) break;
9897 // in non-wildcard mode do some additional checks:
9901 // in case we have an alias-name
9903 if (alias_name
!= NULL
)
9905 s
.device_name
= alias_name
;
9907 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9909 if (entry
!= NULL
) break;
9912 // or by device type
9914 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9916 s
.device_name
= "DEVICE_TYPE_CPU";
9918 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9920 s
.device_name
= "DEVICE_TYPE_GPU";
9922 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9924 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9927 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9929 if (entry
!= NULL
) break;
9933 // free converted device_name
9935 myfree (device_name_nospace
);
9944 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9946 u8 tmp
[256] = { 0 };
9948 if (salt_len
> sizeof (tmp
))
9953 memcpy (tmp
, in
, salt_len
);
9955 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9957 if ((salt_len
% 2) == 0)
9959 u32 new_salt_len
= salt_len
/ 2;
9961 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9966 tmp
[i
] = hex_convert (p1
) << 0;
9967 tmp
[i
] |= hex_convert (p0
) << 4;
9970 salt_len
= new_salt_len
;
9977 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9979 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9982 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9984 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9988 u32
*tmp_uint
= (u32
*) tmp
;
9990 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9991 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9992 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9993 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9994 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9995 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9996 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9997 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9998 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9999 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
10001 salt_len
= salt_len
* 2;
10009 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
10011 lowercase (tmp
, salt_len
);
10014 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
10016 uppercase (tmp
, salt_len
);
10019 u32 len
= salt_len
;
10021 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
10026 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
10031 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
10033 u32
*tmp_uint
= (uint
*) tmp
;
10037 if (len
% 4) max
++;
10039 for (u32 i
= 0; i
< max
; i
++)
10041 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
10044 // Important: we may need to increase the length of memcpy since
10045 // we don't want to "loose" some swapped bytes (could happen if
10046 // they do not perfectly fit in the 4-byte blocks)
10047 // Memcpy does always copy the bytes in the BE order, but since
10048 // we swapped them, some important bytes could be in positions
10049 // we normally skip with the original len
10051 if (len
% 4) len
+= 4 - (len
% 4);
10054 memcpy (out
, tmp
, len
);
10059 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10061 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
10063 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
10065 u32
*digest
= (u32
*) hash_buf
->digest
;
10067 salt_t
*salt
= hash_buf
->salt
;
10069 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
10071 char *iter_pos
= input_buf
+ 4;
10073 salt
->salt_iter
= 1 << atoi (iter_pos
);
10075 char *salt_pos
= strchr (iter_pos
, '$');
10077 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10081 uint salt_len
= 16;
10083 salt
->salt_len
= salt_len
;
10085 u8 tmp_buf
[100] = { 0 };
10087 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
10089 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10091 memcpy (salt_buf_ptr
, tmp_buf
, 16);
10093 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
10094 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
10095 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
10096 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
10098 char *hash_pos
= salt_pos
+ 22;
10100 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10102 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
10104 memcpy (digest
, tmp_buf
, 24);
10106 digest
[0] = byte_swap_32 (digest
[0]);
10107 digest
[1] = byte_swap_32 (digest
[1]);
10108 digest
[2] = byte_swap_32 (digest
[2]);
10109 digest
[3] = byte_swap_32 (digest
[3]);
10110 digest
[4] = byte_swap_32 (digest
[4]);
10111 digest
[5] = byte_swap_32 (digest
[5]);
10113 digest
[5] &= ~0xff; // its just 23 not 24 !
10115 return (PARSER_OK
);
10118 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10120 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
10122 u32
*digest
= (u32
*) hash_buf
->digest
;
10124 u8 tmp_buf
[100] = { 0 };
10126 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
10128 memcpy (digest
, tmp_buf
, 32);
10130 digest
[0] = byte_swap_32 (digest
[0]);
10131 digest
[1] = byte_swap_32 (digest
[1]);
10132 digest
[2] = byte_swap_32 (digest
[2]);
10133 digest
[3] = byte_swap_32 (digest
[3]);
10134 digest
[4] = byte_swap_32 (digest
[4]);
10135 digest
[5] = byte_swap_32 (digest
[5]);
10136 digest
[6] = byte_swap_32 (digest
[6]);
10137 digest
[7] = byte_swap_32 (digest
[7]);
10139 digest
[0] -= SHA256M_A
;
10140 digest
[1] -= SHA256M_B
;
10141 digest
[2] -= SHA256M_C
;
10142 digest
[3] -= SHA256M_D
;
10143 digest
[4] -= SHA256M_E
;
10144 digest
[5] -= SHA256M_F
;
10145 digest
[6] -= SHA256M_G
;
10146 digest
[7] -= SHA256M_H
;
10148 return (PARSER_OK
);
10151 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10153 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10155 u32
*digest
= (u32
*) hash_buf
->digest
;
10157 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10158 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10160 digest
[0] = byte_swap_32 (digest
[0]);
10161 digest
[1] = byte_swap_32 (digest
[1]);
10165 IP (digest
[0], digest
[1], tt
);
10167 digest
[0] = digest
[0];
10168 digest
[1] = digest
[1];
10172 return (PARSER_OK
);
10175 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10177 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10179 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10181 u32
*digest
= (u32
*) hash_buf
->digest
;
10183 salt_t
*salt
= hash_buf
->salt
;
10185 char *hash_pos
= input_buf
+ 10;
10187 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10188 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10189 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10190 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10191 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10193 digest
[0] -= SHA1M_A
;
10194 digest
[1] -= SHA1M_B
;
10195 digest
[2] -= SHA1M_C
;
10196 digest
[3] -= SHA1M_D
;
10197 digest
[4] -= SHA1M_E
;
10199 uint salt_len
= 10;
10201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10203 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10207 salt
->salt_len
= salt_len
;
10209 return (PARSER_OK
);
10212 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10214 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10216 u32
*digest
= (u32
*) hash_buf
->digest
;
10218 salt_t
*salt
= hash_buf
->salt
;
10220 char *hash_pos
= input_buf
+ 8;
10222 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10223 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10224 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10225 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10226 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10228 digest
[0] -= SHA1M_A
;
10229 digest
[1] -= SHA1M_B
;
10230 digest
[2] -= SHA1M_C
;
10231 digest
[3] -= SHA1M_D
;
10232 digest
[4] -= SHA1M_E
;
10236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10238 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10242 salt
->salt_len
= salt_len
;
10244 return (PARSER_OK
);
10247 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10249 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10251 u64
*digest
= (u64
*) hash_buf
->digest
;
10253 salt_t
*salt
= hash_buf
->salt
;
10255 char *hash_pos
= input_buf
+ 8;
10257 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10258 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10259 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10260 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10261 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10262 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10263 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10264 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10266 digest
[0] -= SHA512M_A
;
10267 digest
[1] -= SHA512M_B
;
10268 digest
[2] -= SHA512M_C
;
10269 digest
[3] -= SHA512M_D
;
10270 digest
[4] -= SHA512M_E
;
10271 digest
[5] -= SHA512M_F
;
10272 digest
[6] -= SHA512M_G
;
10273 digest
[7] -= SHA512M_H
;
10277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10279 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10283 salt
->salt_len
= salt_len
;
10285 return (PARSER_OK
);
10288 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10290 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10292 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10296 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10299 u32
*digest
= (u32
*) hash_buf
->digest
;
10301 salt_t
*salt
= hash_buf
->salt
;
10303 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10304 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10305 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10306 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10308 digest
[0] = byte_swap_32 (digest
[0]);
10309 digest
[1] = byte_swap_32 (digest
[1]);
10310 digest
[2] = byte_swap_32 (digest
[2]);
10311 digest
[3] = byte_swap_32 (digest
[3]);
10313 digest
[0] -= MD5M_A
;
10314 digest
[1] -= MD5M_B
;
10315 digest
[2] -= MD5M_C
;
10316 digest
[3] -= MD5M_D
;
10318 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10320 uint salt_len
= input_len
- 32 - 1;
10322 char *salt_buf
= input_buf
+ 32 + 1;
10324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10328 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10330 salt
->salt_len
= salt_len
;
10332 return (PARSER_OK
);
10335 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10337 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10339 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10343 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10348 char clean_input_buf
[32] = { 0 };
10350 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10351 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10353 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10357 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10363 clean_input_buf
[k
] = input_buf
[i
];
10371 u32
*digest
= (u32
*) hash_buf
->digest
;
10373 salt_t
*salt
= hash_buf
->salt
;
10375 u32 a
, b
, c
, d
, e
, f
;
10377 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10378 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10379 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10380 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10381 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10382 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10384 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10385 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10387 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10388 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10389 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10390 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10391 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10392 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10394 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10395 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10397 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10398 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10399 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10400 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10401 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10402 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10404 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10405 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10407 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10408 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10409 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10410 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10411 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10412 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10414 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10415 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10417 digest
[0] = byte_swap_32 (digest
[0]);
10418 digest
[1] = byte_swap_32 (digest
[1]);
10419 digest
[2] = byte_swap_32 (digest
[2]);
10420 digest
[3] = byte_swap_32 (digest
[3]);
10422 digest
[0] -= MD5M_A
;
10423 digest
[1] -= MD5M_B
;
10424 digest
[2] -= MD5M_C
;
10425 digest
[3] -= MD5M_D
;
10427 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10429 uint salt_len
= input_len
- 30 - 1;
10431 char *salt_buf
= input_buf
+ 30 + 1;
10433 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10435 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10437 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10438 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10440 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10442 salt
->salt_len
= salt_len
;
10444 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10446 salt
->salt_len
+= 22;
10448 return (PARSER_OK
);
10451 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10453 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10455 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10459 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10462 u32
*digest
= (u32
*) hash_buf
->digest
;
10464 salt_t
*salt
= hash_buf
->salt
;
10466 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10467 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10468 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10469 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10470 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10472 digest
[0] -= SHA1M_A
;
10473 digest
[1] -= SHA1M_B
;
10474 digest
[2] -= SHA1M_C
;
10475 digest
[3] -= SHA1M_D
;
10476 digest
[4] -= SHA1M_E
;
10478 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10480 uint salt_len
= input_len
- 40 - 1;
10482 char *salt_buf
= input_buf
+ 40 + 1;
10484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10490 salt
->salt_len
= salt_len
;
10492 return (PARSER_OK
);
10495 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10497 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10499 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10503 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10506 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10508 char *iter_pos
= input_buf
+ 6;
10510 salt_t
*salt
= hash_buf
->salt
;
10512 uint iter
= atoi (iter_pos
);
10516 iter
= ROUNDS_DCC2
;
10519 salt
->salt_iter
= iter
- 1;
10521 char *salt_pos
= strchr (iter_pos
, '#');
10523 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10527 char *digest_pos
= strchr (salt_pos
, '#');
10529 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10533 uint salt_len
= digest_pos
- salt_pos
- 1;
10535 u32
*digest
= (u32
*) hash_buf
->digest
;
10537 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10538 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10539 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10540 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10542 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10544 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10546 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10548 salt
->salt_len
= salt_len
;
10550 return (PARSER_OK
);
10553 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10555 u32
*digest
= (u32
*) hash_buf
->digest
;
10557 salt_t
*salt
= hash_buf
->salt
;
10559 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10563 memcpy (&in
, input_buf
, input_len
);
10565 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10567 memcpy (digest
, in
.keymic
, 16);
10570 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10571 The phrase "Pairwise key expansion"
10572 Access Point Address (referred to as Authenticator Address AA)
10573 Supplicant Address (referred to as Supplicant Address SA)
10574 Access Point Nonce (referred to as Authenticator Anonce)
10575 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10578 uint salt_len
= strlen (in
.essid
);
10582 log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
10584 return (PARSER_SALT_LENGTH
);
10587 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10589 salt
->salt_len
= salt_len
;
10591 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10593 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10595 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10597 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10599 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10600 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10604 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10605 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10608 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10610 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10611 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10615 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10616 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10619 for (int i
= 0; i
< 25; i
++)
10621 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10624 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10625 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10626 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10627 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10629 wpa
->keyver
= in
.keyver
;
10631 if (wpa
->keyver
> 255)
10633 log_info ("ATTENTION!");
10634 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10635 log_info (" This could be due to a recent aircrack-ng bug.");
10636 log_info (" The key version was automatically reset to a reasonable value.");
10639 wpa
->keyver
&= 0xff;
10642 wpa
->eapol_size
= in
.eapol_size
;
10644 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10646 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10648 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10650 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10652 if (wpa
->keyver
== 1)
10658 digest
[0] = byte_swap_32 (digest
[0]);
10659 digest
[1] = byte_swap_32 (digest
[1]);
10660 digest
[2] = byte_swap_32 (digest
[2]);
10661 digest
[3] = byte_swap_32 (digest
[3]);
10663 for (int i
= 0; i
< 64; i
++)
10665 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10669 uint32_t *p0
= (uint32_t *) in
.essid
;
10673 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10674 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10676 salt
->salt_buf
[10] = c0
;
10677 salt
->salt_buf
[11] = c1
;
10679 return (PARSER_OK
);
10682 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10684 u32
*digest
= (u32
*) hash_buf
->digest
;
10686 salt_t
*salt
= hash_buf
->salt
;
10688 if (input_len
== 0)
10690 log_error ("Password Safe v2 container not specified");
10695 FILE *fp
= fopen (input_buf
, "rb");
10699 log_error ("%s: %s", input_buf
, strerror (errno
));
10706 memset (&buf
, 0, sizeof (psafe2_hdr
));
10708 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10712 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10714 salt
->salt_buf
[0] = buf
.random
[0];
10715 salt
->salt_buf
[1] = buf
.random
[1];
10717 salt
->salt_len
= 8;
10718 salt
->salt_iter
= 1000;
10720 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10721 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10722 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10723 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10724 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10726 return (PARSER_OK
);
10729 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10731 u32
*digest
= (u32
*) hash_buf
->digest
;
10733 salt_t
*salt
= hash_buf
->salt
;
10735 if (input_len
== 0)
10737 log_error (".psafe3 not specified");
10742 FILE *fp
= fopen (input_buf
, "rb");
10746 log_error ("%s: %s", input_buf
, strerror (errno
));
10753 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10757 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10759 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10761 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10763 salt
->salt_iter
= in
.iterations
+ 1;
10765 salt
->salt_buf
[0] = in
.salt_buf
[0];
10766 salt
->salt_buf
[1] = in
.salt_buf
[1];
10767 salt
->salt_buf
[2] = in
.salt_buf
[2];
10768 salt
->salt_buf
[3] = in
.salt_buf
[3];
10769 salt
->salt_buf
[4] = in
.salt_buf
[4];
10770 salt
->salt_buf
[5] = in
.salt_buf
[5];
10771 salt
->salt_buf
[6] = in
.salt_buf
[6];
10772 salt
->salt_buf
[7] = in
.salt_buf
[7];
10774 salt
->salt_len
= 32;
10776 digest
[0] = in
.hash_buf
[0];
10777 digest
[1] = in
.hash_buf
[1];
10778 digest
[2] = in
.hash_buf
[2];
10779 digest
[3] = in
.hash_buf
[3];
10780 digest
[4] = in
.hash_buf
[4];
10781 digest
[5] = in
.hash_buf
[5];
10782 digest
[6] = in
.hash_buf
[6];
10783 digest
[7] = in
.hash_buf
[7];
10785 digest
[0] = byte_swap_32 (digest
[0]);
10786 digest
[1] = byte_swap_32 (digest
[1]);
10787 digest
[2] = byte_swap_32 (digest
[2]);
10788 digest
[3] = byte_swap_32 (digest
[3]);
10789 digest
[4] = byte_swap_32 (digest
[4]);
10790 digest
[5] = byte_swap_32 (digest
[5]);
10791 digest
[6] = byte_swap_32 (digest
[6]);
10792 digest
[7] = byte_swap_32 (digest
[7]);
10794 return (PARSER_OK
);
10797 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10799 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10801 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10803 u32
*digest
= (u32
*) hash_buf
->digest
;
10805 salt_t
*salt
= hash_buf
->salt
;
10807 char *iter_pos
= input_buf
+ 3;
10809 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10811 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10813 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10815 salt
->salt_iter
= salt_iter
;
10817 char *salt_pos
= iter_pos
+ 1;
10821 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10823 salt
->salt_len
= salt_len
;
10825 char *hash_pos
= salt_pos
+ salt_len
;
10827 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10829 return (PARSER_OK
);
10832 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10834 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10836 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10838 u32
*digest
= (u32
*) hash_buf
->digest
;
10840 salt_t
*salt
= hash_buf
->salt
;
10842 char *salt_pos
= input_buf
+ 3;
10844 uint iterations_len
= 0;
10846 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10850 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10852 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10853 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10857 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10861 iterations_len
+= 8;
10865 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10868 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10870 char *hash_pos
= strchr (salt_pos
, '$');
10872 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10874 uint salt_len
= hash_pos
- salt_pos
;
10876 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10878 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10880 salt
->salt_len
= salt_len
;
10884 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10886 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10888 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10890 return (PARSER_OK
);
10893 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10895 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10897 u32
*digest
= (u32
*) hash_buf
->digest
;
10899 salt_t
*salt
= hash_buf
->salt
;
10901 char *salt_pos
= input_buf
+ 6;
10903 uint iterations_len
= 0;
10905 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10909 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10911 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10912 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10916 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10920 iterations_len
+= 8;
10924 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10927 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10929 char *hash_pos
= strchr (salt_pos
, '$');
10931 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10933 uint salt_len
= hash_pos
- salt_pos
;
10935 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10937 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10939 salt
->salt_len
= salt_len
;
10943 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10945 return (PARSER_OK
);
10948 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10950 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10952 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10954 u32
*digest
= (u32
*) hash_buf
->digest
;
10956 salt_t
*salt
= hash_buf
->salt
;
10958 char *salt_pos
= input_buf
+ 14;
10960 char *hash_pos
= strchr (salt_pos
, '*');
10962 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10966 uint salt_len
= hash_pos
- salt_pos
- 1;
10968 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10970 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10972 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10974 salt
->salt_len
= salt_len
;
10976 u8 tmp_buf
[100] = { 0 };
10978 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10980 memcpy (digest
, tmp_buf
, 20);
10982 digest
[0] = byte_swap_32 (digest
[0]);
10983 digest
[1] = byte_swap_32 (digest
[1]);
10984 digest
[2] = byte_swap_32 (digest
[2]);
10985 digest
[3] = byte_swap_32 (digest
[3]);
10986 digest
[4] = byte_swap_32 (digest
[4]);
10988 digest
[0] -= SHA1M_A
;
10989 digest
[1] -= SHA1M_B
;
10990 digest
[2] -= SHA1M_C
;
10991 digest
[3] -= SHA1M_D
;
10992 digest
[4] -= SHA1M_E
;
10994 return (PARSER_OK
);
10997 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10999 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
11001 unsigned char c12
= itoa64_to_int (input_buf
[12]);
11003 if (c12
& 3) return (PARSER_HASH_VALUE
);
11005 u32
*digest
= (u32
*) hash_buf
->digest
;
11007 salt_t
*salt
= hash_buf
->salt
;
11009 // for ascii_digest
11010 salt
->salt_sign
[0] = input_buf
[0];
11011 salt
->salt_sign
[1] = input_buf
[1];
11013 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
11014 | itoa64_to_int (input_buf
[1]) << 6;
11016 salt
->salt_len
= 2;
11018 u8 tmp_buf
[100] = { 0 };
11020 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
11022 memcpy (digest
, tmp_buf
, 8);
11026 IP (digest
[0], digest
[1], tt
);
11031 return (PARSER_OK
);
11034 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11036 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
11038 u32
*digest
= (u32
*) hash_buf
->digest
;
11040 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11041 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11042 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11043 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11045 digest
[0] = byte_swap_32 (digest
[0]);
11046 digest
[1] = byte_swap_32 (digest
[1]);
11047 digest
[2] = byte_swap_32 (digest
[2]);
11048 digest
[3] = byte_swap_32 (digest
[3]);
11050 digest
[0] -= MD4M_A
;
11051 digest
[1] -= MD4M_B
;
11052 digest
[2] -= MD4M_C
;
11053 digest
[3] -= MD4M_D
;
11055 return (PARSER_OK
);
11058 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11060 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11062 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
11066 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
11069 u32
*digest
= (u32
*) hash_buf
->digest
;
11071 salt_t
*salt
= hash_buf
->salt
;
11073 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11074 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11075 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11076 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11078 digest
[0] = byte_swap_32 (digest
[0]);
11079 digest
[1] = byte_swap_32 (digest
[1]);
11080 digest
[2] = byte_swap_32 (digest
[2]);
11081 digest
[3] = byte_swap_32 (digest
[3]);
11083 digest
[0] -= MD4M_A
;
11084 digest
[1] -= MD4M_B
;
11085 digest
[2] -= MD4M_C
;
11086 digest
[3] -= MD4M_D
;
11088 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11090 uint salt_len
= input_len
- 32 - 1;
11092 char *salt_buf
= input_buf
+ 32 + 1;
11094 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11100 salt
->salt_len
= salt_len
;
11102 return (PARSER_OK
);
11105 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11107 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
11109 u32
*digest
= (u32
*) hash_buf
->digest
;
11111 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11112 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11113 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11114 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11116 digest
[0] = byte_swap_32 (digest
[0]);
11117 digest
[1] = byte_swap_32 (digest
[1]);
11118 digest
[2] = byte_swap_32 (digest
[2]);
11119 digest
[3] = byte_swap_32 (digest
[3]);
11121 digest
[0] -= MD5M_A
;
11122 digest
[1] -= MD5M_B
;
11123 digest
[2] -= MD5M_C
;
11124 digest
[3] -= MD5M_D
;
11126 return (PARSER_OK
);
11129 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11131 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
11133 u32
*digest
= (u32
*) hash_buf
->digest
;
11135 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
11136 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
11140 digest
[0] = byte_swap_32 (digest
[0]);
11141 digest
[1] = byte_swap_32 (digest
[1]);
11143 return (PARSER_OK
);
11146 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11148 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11150 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11154 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11157 u32
*digest
= (u32
*) hash_buf
->digest
;
11159 salt_t
*salt
= hash_buf
->salt
;
11161 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11162 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11163 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11164 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11166 digest
[0] = byte_swap_32 (digest
[0]);
11167 digest
[1] = byte_swap_32 (digest
[1]);
11168 digest
[2] = byte_swap_32 (digest
[2]);
11169 digest
[3] = byte_swap_32 (digest
[3]);
11171 digest
[0] -= MD5M_A
;
11172 digest
[1] -= MD5M_B
;
11173 digest
[2] -= MD5M_C
;
11174 digest
[3] -= MD5M_D
;
11176 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11178 uint salt_len
= input_len
- 32 - 1;
11180 char *salt_buf
= input_buf
+ 32 + 1;
11182 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11184 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11186 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11188 salt
->salt_len
= salt_len
;
11190 return (PARSER_OK
);
11193 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11195 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11197 u32
*digest
= (u32
*) hash_buf
->digest
;
11199 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11200 | itoa64_to_int (input_buf
[ 1]) << 6
11201 | itoa64_to_int (input_buf
[ 2]) << 12
11202 | itoa64_to_int (input_buf
[ 3]) << 18;
11203 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11204 | itoa64_to_int (input_buf
[ 5]) << 6
11205 | itoa64_to_int (input_buf
[ 6]) << 12
11206 | itoa64_to_int (input_buf
[ 7]) << 18;
11207 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11208 | itoa64_to_int (input_buf
[ 9]) << 6
11209 | itoa64_to_int (input_buf
[10]) << 12
11210 | itoa64_to_int (input_buf
[11]) << 18;
11211 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11212 | itoa64_to_int (input_buf
[13]) << 6
11213 | itoa64_to_int (input_buf
[14]) << 12
11214 | itoa64_to_int (input_buf
[15]) << 18;
11216 digest
[0] -= MD5M_A
;
11217 digest
[1] -= MD5M_B
;
11218 digest
[2] -= MD5M_C
;
11219 digest
[3] -= MD5M_D
;
11221 digest
[0] &= 0x00ffffff;
11222 digest
[1] &= 0x00ffffff;
11223 digest
[2] &= 0x00ffffff;
11224 digest
[3] &= 0x00ffffff;
11226 return (PARSER_OK
);
11229 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11231 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11233 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11237 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11240 u32
*digest
= (u32
*) hash_buf
->digest
;
11242 salt_t
*salt
= hash_buf
->salt
;
11244 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11245 | itoa64_to_int (input_buf
[ 1]) << 6
11246 | itoa64_to_int (input_buf
[ 2]) << 12
11247 | itoa64_to_int (input_buf
[ 3]) << 18;
11248 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11249 | itoa64_to_int (input_buf
[ 5]) << 6
11250 | itoa64_to_int (input_buf
[ 6]) << 12
11251 | itoa64_to_int (input_buf
[ 7]) << 18;
11252 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11253 | itoa64_to_int (input_buf
[ 9]) << 6
11254 | itoa64_to_int (input_buf
[10]) << 12
11255 | itoa64_to_int (input_buf
[11]) << 18;
11256 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11257 | itoa64_to_int (input_buf
[13]) << 6
11258 | itoa64_to_int (input_buf
[14]) << 12
11259 | itoa64_to_int (input_buf
[15]) << 18;
11261 digest
[0] -= MD5M_A
;
11262 digest
[1] -= MD5M_B
;
11263 digest
[2] -= MD5M_C
;
11264 digest
[3] -= MD5M_D
;
11266 digest
[0] &= 0x00ffffff;
11267 digest
[1] &= 0x00ffffff;
11268 digest
[2] &= 0x00ffffff;
11269 digest
[3] &= 0x00ffffff;
11271 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11273 uint salt_len
= input_len
- 16 - 1;
11275 char *salt_buf
= input_buf
+ 16 + 1;
11277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11283 salt
->salt_len
= salt_len
;
11285 return (PARSER_OK
);
11288 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11290 key
[0] = (nthash
[0] >> 0);
11291 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11292 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11293 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11294 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11295 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11296 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11297 key
[7] = (nthash
[6] << 1);
11309 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11311 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11313 u32
*digest
= (u32
*) hash_buf
->digest
;
11315 salt_t
*salt
= hash_buf
->salt
;
11317 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11323 char *user_pos
= input_buf
;
11325 char *unused_pos
= strchr (user_pos
, ':');
11327 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11329 uint user_len
= unused_pos
- user_pos
;
11331 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11335 char *domain_pos
= strchr (unused_pos
, ':');
11337 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11339 uint unused_len
= domain_pos
- unused_pos
;
11341 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11345 char *srvchall_pos
= strchr (domain_pos
, ':');
11347 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11349 uint domain_len
= srvchall_pos
- domain_pos
;
11351 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11355 char *hash_pos
= strchr (srvchall_pos
, ':');
11357 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11359 uint srvchall_len
= hash_pos
- srvchall_pos
;
11361 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11365 char *clichall_pos
= strchr (hash_pos
, ':');
11367 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11369 uint hash_len
= clichall_pos
- hash_pos
;
11371 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11375 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11377 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11380 * store some data for later use
11383 netntlm
->user_len
= user_len
* 2;
11384 netntlm
->domain_len
= domain_len
* 2;
11385 netntlm
->srvchall_len
= srvchall_len
/ 2;
11386 netntlm
->clichall_len
= clichall_len
/ 2;
11388 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11389 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11392 * handle username and domainname
11395 for (uint i
= 0; i
< user_len
; i
++)
11397 *userdomain_ptr
++ = user_pos
[i
];
11398 *userdomain_ptr
++ = 0;
11401 for (uint i
= 0; i
< domain_len
; i
++)
11403 *userdomain_ptr
++ = domain_pos
[i
];
11404 *userdomain_ptr
++ = 0;
11408 * handle server challenge encoding
11411 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11413 const char p0
= srvchall_pos
[i
+ 0];
11414 const char p1
= srvchall_pos
[i
+ 1];
11416 *chall_ptr
++ = hex_convert (p1
) << 0
11417 | hex_convert (p0
) << 4;
11421 * handle client challenge encoding
11424 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11426 const char p0
= clichall_pos
[i
+ 0];
11427 const char p1
= clichall_pos
[i
+ 1];
11429 *chall_ptr
++ = hex_convert (p1
) << 0
11430 | hex_convert (p0
) << 4;
11437 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11439 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11441 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11443 salt
->salt_len
= salt_len
;
11445 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11446 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11447 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11448 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11450 digest
[0] = byte_swap_32 (digest
[0]);
11451 digest
[1] = byte_swap_32 (digest
[1]);
11452 digest
[2] = byte_swap_32 (digest
[2]);
11453 digest
[3] = byte_swap_32 (digest
[3]);
11455 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11457 uint digest_tmp
[2] = { 0 };
11459 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11460 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11462 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11463 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11465 /* special case 2: ESS */
11467 if (srvchall_len
== 48)
11469 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11471 uint w
[16] = { 0 };
11473 w
[ 0] = netntlm
->chall_buf
[6];
11474 w
[ 1] = netntlm
->chall_buf
[7];
11475 w
[ 2] = netntlm
->chall_buf
[0];
11476 w
[ 3] = netntlm
->chall_buf
[1];
11480 uint dgst
[4] = { 0 };
11489 salt
->salt_buf
[0] = dgst
[0];
11490 salt
->salt_buf
[1] = dgst
[1];
11494 /* precompute netntlmv1 exploit start */
11496 for (uint i
= 0; i
< 0x10000; i
++)
11498 uint key_md4
[2] = { i
, 0 };
11499 uint key_des
[2] = { 0, 0 };
11501 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11503 uint Kc
[16] = { 0 };
11504 uint Kd
[16] = { 0 };
11506 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11508 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11510 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11512 if (data3
[0] != digest_tmp
[0]) continue;
11513 if (data3
[1] != digest_tmp
[1]) continue;
11515 salt
->salt_buf
[2] = i
;
11517 salt
->salt_len
= 24;
11522 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11523 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11525 /* precompute netntlmv1 exploit stop */
11529 IP (digest
[0], digest
[1], tt
);
11530 IP (digest
[2], digest
[3], tt
);
11532 digest
[0] = rotr32 (digest
[0], 29);
11533 digest
[1] = rotr32 (digest
[1], 29);
11534 digest
[2] = rotr32 (digest
[2], 29);
11535 digest
[3] = rotr32 (digest
[3], 29);
11537 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11539 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11540 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11542 return (PARSER_OK
);
11545 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11547 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11549 u32
*digest
= (u32
*) hash_buf
->digest
;
11551 salt_t
*salt
= hash_buf
->salt
;
11553 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11559 char *user_pos
= input_buf
;
11561 char *unused_pos
= strchr (user_pos
, ':');
11563 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11565 uint user_len
= unused_pos
- user_pos
;
11567 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11571 char *domain_pos
= strchr (unused_pos
, ':');
11573 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11575 uint unused_len
= domain_pos
- unused_pos
;
11577 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11581 char *srvchall_pos
= strchr (domain_pos
, ':');
11583 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11585 uint domain_len
= srvchall_pos
- domain_pos
;
11587 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11591 char *hash_pos
= strchr (srvchall_pos
, ':');
11593 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11595 uint srvchall_len
= hash_pos
- srvchall_pos
;
11597 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11601 char *clichall_pos
= strchr (hash_pos
, ':');
11603 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11605 uint hash_len
= clichall_pos
- hash_pos
;
11607 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11611 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11613 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11615 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11618 * store some data for later use
11621 netntlm
->user_len
= user_len
* 2;
11622 netntlm
->domain_len
= domain_len
* 2;
11623 netntlm
->srvchall_len
= srvchall_len
/ 2;
11624 netntlm
->clichall_len
= clichall_len
/ 2;
11626 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11627 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11630 * handle username and domainname
11633 for (uint i
= 0; i
< user_len
; i
++)
11635 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11636 *userdomain_ptr
++ = 0;
11639 for (uint i
= 0; i
< domain_len
; i
++)
11641 *userdomain_ptr
++ = domain_pos
[i
];
11642 *userdomain_ptr
++ = 0;
11645 *userdomain_ptr
++ = 0x80;
11648 * handle server challenge encoding
11651 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11653 const char p0
= srvchall_pos
[i
+ 0];
11654 const char p1
= srvchall_pos
[i
+ 1];
11656 *chall_ptr
++ = hex_convert (p1
) << 0
11657 | hex_convert (p0
) << 4;
11661 * handle client challenge encoding
11664 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11666 const char p0
= clichall_pos
[i
+ 0];
11667 const char p1
= clichall_pos
[i
+ 1];
11669 *chall_ptr
++ = hex_convert (p1
) << 0
11670 | hex_convert (p0
) << 4;
11673 *chall_ptr
++ = 0x80;
11676 * handle hash itself
11679 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11680 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11681 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11682 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11684 digest
[0] = byte_swap_32 (digest
[0]);
11685 digest
[1] = byte_swap_32 (digest
[1]);
11686 digest
[2] = byte_swap_32 (digest
[2]);
11687 digest
[3] = byte_swap_32 (digest
[3]);
11690 * reuse challange data as salt_buf, its the buffer that is most likely unique
11693 salt
->salt_buf
[0] = 0;
11694 salt
->salt_buf
[1] = 0;
11695 salt
->salt_buf
[2] = 0;
11696 salt
->salt_buf
[3] = 0;
11697 salt
->salt_buf
[4] = 0;
11698 salt
->salt_buf
[5] = 0;
11699 salt
->salt_buf
[6] = 0;
11700 salt
->salt_buf
[7] = 0;
11704 uptr
= (uint
*) netntlm
->userdomain_buf
;
11706 for (uint i
= 0; i
< 16; i
+= 16)
11708 md5_64 (uptr
, salt
->salt_buf
);
11711 uptr
= (uint
*) netntlm
->chall_buf
;
11713 for (uint i
= 0; i
< 256; i
+= 16)
11715 md5_64 (uptr
, salt
->salt_buf
);
11718 salt
->salt_len
= 16;
11720 return (PARSER_OK
);
11723 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11725 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11727 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11731 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11734 u32
*digest
= (u32
*) hash_buf
->digest
;
11736 salt_t
*salt
= hash_buf
->salt
;
11738 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11739 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11740 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11741 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11743 digest
[0] = byte_swap_32 (digest
[0]);
11744 digest
[1] = byte_swap_32 (digest
[1]);
11745 digest
[2] = byte_swap_32 (digest
[2]);
11746 digest
[3] = byte_swap_32 (digest
[3]);
11748 digest
[0] -= MD5M_A
;
11749 digest
[1] -= MD5M_B
;
11750 digest
[2] -= MD5M_C
;
11751 digest
[3] -= MD5M_D
;
11753 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11755 uint salt_len
= input_len
- 32 - 1;
11757 char *salt_buf
= input_buf
+ 32 + 1;
11759 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11761 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11763 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11765 salt
->salt_len
= salt_len
;
11767 return (PARSER_OK
);
11770 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11772 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11774 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11778 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11781 u32
*digest
= (u32
*) hash_buf
->digest
;
11783 salt_t
*salt
= hash_buf
->salt
;
11785 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11786 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11787 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11788 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11790 digest
[0] = byte_swap_32 (digest
[0]);
11791 digest
[1] = byte_swap_32 (digest
[1]);
11792 digest
[2] = byte_swap_32 (digest
[2]);
11793 digest
[3] = byte_swap_32 (digest
[3]);
11795 digest
[0] -= MD5M_A
;
11796 digest
[1] -= MD5M_B
;
11797 digest
[2] -= MD5M_C
;
11798 digest
[3] -= MD5M_D
;
11800 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11802 uint salt_len
= input_len
- 32 - 1;
11804 char *salt_buf
= input_buf
+ 32 + 1;
11806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11812 salt
->salt_len
= salt_len
;
11814 return (PARSER_OK
);
11817 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11819 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11821 u32
*digest
= (u32
*) hash_buf
->digest
;
11823 salt_t
*salt
= hash_buf
->salt
;
11825 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11826 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11827 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11828 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11830 digest
[0] = byte_swap_32 (digest
[0]);
11831 digest
[1] = byte_swap_32 (digest
[1]);
11832 digest
[2] = byte_swap_32 (digest
[2]);
11833 digest
[3] = byte_swap_32 (digest
[3]);
11835 digest
[0] -= MD5M_A
;
11836 digest
[1] -= MD5M_B
;
11837 digest
[2] -= MD5M_C
;
11838 digest
[3] -= MD5M_D
;
11841 * This is a virtual salt. While the algorithm is basically not salted
11842 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11843 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11846 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11848 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11850 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11852 salt
->salt_len
= salt_len
;
11854 return (PARSER_OK
);
11857 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11859 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11861 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11865 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11868 u32
*digest
= (u32
*) hash_buf
->digest
;
11870 salt_t
*salt
= hash_buf
->salt
;
11872 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11873 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11874 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11875 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11877 digest
[0] = byte_swap_32 (digest
[0]);
11878 digest
[1] = byte_swap_32 (digest
[1]);
11879 digest
[2] = byte_swap_32 (digest
[2]);
11880 digest
[3] = byte_swap_32 (digest
[3]);
11882 digest
[0] -= MD5M_A
;
11883 digest
[1] -= MD5M_B
;
11884 digest
[2] -= MD5M_C
;
11885 digest
[3] -= MD5M_D
;
11887 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11889 uint salt_len
= input_len
- 32 - 1;
11891 char *salt_buf
= input_buf
+ 32 + 1;
11893 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11895 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11897 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11899 salt
->salt_len
= salt_len
;
11901 return (PARSER_OK
);
11904 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11906 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11908 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11912 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11915 u32
*digest
= (u32
*) hash_buf
->digest
;
11917 salt_t
*salt
= hash_buf
->salt
;
11919 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11920 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11921 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11922 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11924 digest
[0] = byte_swap_32 (digest
[0]);
11925 digest
[1] = byte_swap_32 (digest
[1]);
11926 digest
[2] = byte_swap_32 (digest
[2]);
11927 digest
[3] = byte_swap_32 (digest
[3]);
11929 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11931 uint salt_len
= input_len
- 32 - 1;
11933 char *salt_buf
= input_buf
+ 32 + 1;
11935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11937 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11941 salt
->salt_len
= salt_len
;
11943 return (PARSER_OK
);
11946 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11948 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11950 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11954 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11957 u32
*digest
= (u32
*) hash_buf
->digest
;
11959 salt_t
*salt
= hash_buf
->salt
;
11961 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11962 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11963 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11964 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11966 digest
[0] = byte_swap_32 (digest
[0]);
11967 digest
[1] = byte_swap_32 (digest
[1]);
11968 digest
[2] = byte_swap_32 (digest
[2]);
11969 digest
[3] = byte_swap_32 (digest
[3]);
11971 digest
[0] -= MD4M_A
;
11972 digest
[1] -= MD4M_B
;
11973 digest
[2] -= MD4M_C
;
11974 digest
[3] -= MD4M_D
;
11976 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11978 uint salt_len
= input_len
- 32 - 1;
11980 char *salt_buf
= input_buf
+ 32 + 1;
11982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11984 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11988 salt
->salt_len
= salt_len
;
11990 return (PARSER_OK
);
11993 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11995 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11997 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
12001 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
12004 u32
*digest
= (u32
*) hash_buf
->digest
;
12006 salt_t
*salt
= hash_buf
->salt
;
12008 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12009 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12010 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12011 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12013 digest
[0] = byte_swap_32 (digest
[0]);
12014 digest
[1] = byte_swap_32 (digest
[1]);
12015 digest
[2] = byte_swap_32 (digest
[2]);
12016 digest
[3] = byte_swap_32 (digest
[3]);
12018 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12020 uint salt_len
= input_len
- 32 - 1;
12022 char *salt_buf
= input_buf
+ 32 + 1;
12024 uint salt_pc_block
[16] = { 0 };
12026 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
12028 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
12030 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12032 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
12034 salt_pc_block
[14] = salt_len
* 8;
12036 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
12038 md5_64 (salt_pc_block
, salt_pc_digest
);
12040 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
12041 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
12042 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
12043 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
12045 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
12047 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
12049 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
12051 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
12052 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
12053 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
12054 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
12056 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
12058 return (PARSER_OK
);
12061 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12063 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
12065 u32
*digest
= (u32
*) hash_buf
->digest
;
12067 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12068 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12069 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12070 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12071 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12073 digest
[0] -= SHA1M_A
;
12074 digest
[1] -= SHA1M_B
;
12075 digest
[2] -= SHA1M_C
;
12076 digest
[3] -= SHA1M_D
;
12077 digest
[4] -= SHA1M_E
;
12079 return (PARSER_OK
);
12082 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12084 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
12086 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
12088 u32
*digest
= (u32
*) hash_buf
->digest
;
12092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12098 return (PARSER_OK
);
12101 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12103 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12105 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
12109 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
12112 u32
*digest
= (u32
*) hash_buf
->digest
;
12114 salt_t
*salt
= hash_buf
->salt
;
12116 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12117 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12118 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12119 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12120 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12122 digest
[0] -= SHA1M_A
;
12123 digest
[1] -= SHA1M_B
;
12124 digest
[2] -= SHA1M_C
;
12125 digest
[3] -= SHA1M_D
;
12126 digest
[4] -= SHA1M_E
;
12128 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12130 uint salt_len
= input_len
- 40 - 1;
12132 char *salt_buf
= input_buf
+ 40 + 1;
12134 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12136 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12138 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12140 salt
->salt_len
= salt_len
;
12142 return (PARSER_OK
);
12145 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12147 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12149 u32
*digest
= (u32
*) hash_buf
->digest
;
12151 salt_t
*salt
= hash_buf
->salt
;
12153 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12155 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12156 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12157 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12158 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12159 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12161 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12163 uint salt_len
= input_len
- 40 - 1;
12165 char *salt_buf
= input_buf
+ 40 + 1;
12167 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12169 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12171 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12173 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12176 pstoken
->salt_len
= salt_len
/ 2;
12178 /* some fake salt for the sorting mechanisms */
12180 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12181 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12182 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12183 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12184 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12185 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12186 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12187 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12189 salt
->salt_len
= 32;
12191 /* we need to check if we can precompute some of the data --
12192 this is possible since the scheme is badly designed */
12194 pstoken
->pc_digest
[0] = SHA1M_A
;
12195 pstoken
->pc_digest
[1] = SHA1M_B
;
12196 pstoken
->pc_digest
[2] = SHA1M_C
;
12197 pstoken
->pc_digest
[3] = SHA1M_D
;
12198 pstoken
->pc_digest
[4] = SHA1M_E
;
12200 pstoken
->pc_offset
= 0;
12202 for (int i
= 0; i
< (int) pstoken
->salt_len
- 63; i
+= 64)
12206 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12207 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12208 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12209 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12210 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12211 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12212 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12213 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12214 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12215 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12216 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12217 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12218 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12219 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12220 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12221 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12223 sha1_64 (w
, pstoken
->pc_digest
);
12225 pstoken
->pc_offset
+= 16;
12228 return (PARSER_OK
);
12231 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12233 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12235 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12237 u32
*digest
= (u32
*) hash_buf
->digest
;
12239 u8 tmp_buf
[100] = { 0 };
12241 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12243 memcpy (digest
, tmp_buf
, 20);
12245 digest
[0] = byte_swap_32 (digest
[0]);
12246 digest
[1] = byte_swap_32 (digest
[1]);
12247 digest
[2] = byte_swap_32 (digest
[2]);
12248 digest
[3] = byte_swap_32 (digest
[3]);
12249 digest
[4] = byte_swap_32 (digest
[4]);
12251 digest
[0] -= SHA1M_A
;
12252 digest
[1] -= SHA1M_B
;
12253 digest
[2] -= SHA1M_C
;
12254 digest
[3] -= SHA1M_D
;
12255 digest
[4] -= SHA1M_E
;
12257 return (PARSER_OK
);
12260 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12262 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12264 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12266 u32
*digest
= (u32
*) hash_buf
->digest
;
12268 salt_t
*salt
= hash_buf
->salt
;
12270 u8 tmp_buf
[100] = { 0 };
12272 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12274 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12276 memcpy (digest
, tmp_buf
, 20);
12278 int salt_len
= tmp_len
- 20;
12280 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12282 salt
->salt_len
= salt_len
;
12284 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12286 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12288 char *ptr
= (char *) salt
->salt_buf
;
12290 ptr
[salt
->salt_len
] = 0x80;
12293 digest
[0] = byte_swap_32 (digest
[0]);
12294 digest
[1] = byte_swap_32 (digest
[1]);
12295 digest
[2] = byte_swap_32 (digest
[2]);
12296 digest
[3] = byte_swap_32 (digest
[3]);
12297 digest
[4] = byte_swap_32 (digest
[4]);
12299 digest
[0] -= SHA1M_A
;
12300 digest
[1] -= SHA1M_B
;
12301 digest
[2] -= SHA1M_C
;
12302 digest
[3] -= SHA1M_D
;
12303 digest
[4] -= SHA1M_E
;
12305 return (PARSER_OK
);
12308 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12310 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12312 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12314 u32
*digest
= (u32
*) hash_buf
->digest
;
12316 salt_t
*salt
= hash_buf
->salt
;
12318 char *salt_buf
= input_buf
+ 6;
12322 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12324 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12328 salt
->salt_len
= salt_len
;
12330 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12332 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12333 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12334 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12335 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12336 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12338 digest
[0] -= SHA1M_A
;
12339 digest
[1] -= SHA1M_B
;
12340 digest
[2] -= SHA1M_C
;
12341 digest
[3] -= SHA1M_D
;
12342 digest
[4] -= SHA1M_E
;
12344 return (PARSER_OK
);
12347 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12349 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12351 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12353 u32
*digest
= (u32
*) hash_buf
->digest
;
12355 salt_t
*salt
= hash_buf
->salt
;
12357 char *salt_buf
= input_buf
+ 6;
12361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12367 salt
->salt_len
= salt_len
;
12369 char *hash_pos
= input_buf
+ 6 + 8;
12371 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12372 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12373 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12374 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12375 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12377 digest
[0] -= SHA1M_A
;
12378 digest
[1] -= SHA1M_B
;
12379 digest
[2] -= SHA1M_C
;
12380 digest
[3] -= SHA1M_D
;
12381 digest
[4] -= SHA1M_E
;
12383 return (PARSER_OK
);
12386 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12388 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12390 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12392 u64
*digest
= (u64
*) hash_buf
->digest
;
12394 salt_t
*salt
= hash_buf
->salt
;
12396 char *salt_buf
= input_buf
+ 6;
12400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12402 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12404 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12406 salt
->salt_len
= salt_len
;
12408 char *hash_pos
= input_buf
+ 6 + 8;
12410 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12411 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12412 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12413 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12414 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12415 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12416 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12417 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12419 digest
[0] -= SHA512M_A
;
12420 digest
[1] -= SHA512M_B
;
12421 digest
[2] -= SHA512M_C
;
12422 digest
[3] -= SHA512M_D
;
12423 digest
[4] -= SHA512M_E
;
12424 digest
[5] -= SHA512M_F
;
12425 digest
[6] -= SHA512M_G
;
12426 digest
[7] -= SHA512M_H
;
12428 return (PARSER_OK
);
12431 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12433 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12435 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12439 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12442 u32
*digest
= (u32
*) hash_buf
->digest
;
12444 salt_t
*salt
= hash_buf
->salt
;
12446 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12447 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12451 digest
[0] = byte_swap_32 (digest
[0]);
12452 digest
[1] = byte_swap_32 (digest
[1]);
12454 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12456 uint salt_len
= input_len
- 16 - 1;
12458 char *salt_buf
= input_buf
+ 16 + 1;
12460 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12462 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12464 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12466 salt
->salt_len
= salt_len
;
12468 return (PARSER_OK
);
12471 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12473 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12475 u32
*digest
= (u32
*) hash_buf
->digest
;
12477 salt_t
*salt
= hash_buf
->salt
;
12479 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12480 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12481 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12482 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12483 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12485 digest
[0] -= SHA1M_A
;
12486 digest
[1] -= SHA1M_B
;
12487 digest
[2] -= SHA1M_C
;
12488 digest
[3] -= SHA1M_D
;
12489 digest
[4] -= SHA1M_E
;
12491 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12493 uint salt_len
= input_len
- 40 - 1;
12495 char *salt_buf
= input_buf
+ 40 + 1;
12497 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12499 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12501 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12503 salt
->salt_len
= salt_len
;
12505 return (PARSER_OK
);
12508 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12510 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12512 u32
*digest
= (u32
*) hash_buf
->digest
;
12514 salt_t
*salt
= hash_buf
->salt
;
12516 char *hash_pos
= input_buf
;
12518 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12519 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12520 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12521 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12522 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12523 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12524 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12525 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12526 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12527 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12528 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12529 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12530 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12531 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12532 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12533 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12535 char *salt_pos
= input_buf
+ 128;
12537 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12538 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12539 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12540 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12542 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12543 salt
->salt_len
= 16;
12545 return (PARSER_OK
);
12548 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12550 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12552 u32
*digest
= (u32
*) hash_buf
->digest
;
12554 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12555 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12556 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12557 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12558 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12559 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12560 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12561 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12563 digest
[0] -= SHA256M_A
;
12564 digest
[1] -= SHA256M_B
;
12565 digest
[2] -= SHA256M_C
;
12566 digest
[3] -= SHA256M_D
;
12567 digest
[4] -= SHA256M_E
;
12568 digest
[5] -= SHA256M_F
;
12569 digest
[6] -= SHA256M_G
;
12570 digest
[7] -= SHA256M_H
;
12572 return (PARSER_OK
);
12575 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12577 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12579 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12583 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12586 u32
*digest
= (u32
*) hash_buf
->digest
;
12588 salt_t
*salt
= hash_buf
->salt
;
12590 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12591 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12592 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12593 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12594 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12595 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12596 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12597 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12599 digest
[0] -= SHA256M_A
;
12600 digest
[1] -= SHA256M_B
;
12601 digest
[2] -= SHA256M_C
;
12602 digest
[3] -= SHA256M_D
;
12603 digest
[4] -= SHA256M_E
;
12604 digest
[5] -= SHA256M_F
;
12605 digest
[6] -= SHA256M_G
;
12606 digest
[7] -= SHA256M_H
;
12608 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12610 uint salt_len
= input_len
- 64 - 1;
12612 char *salt_buf
= input_buf
+ 64 + 1;
12614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12616 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12620 salt
->salt_len
= salt_len
;
12622 return (PARSER_OK
);
12625 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12627 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12629 u64
*digest
= (u64
*) hash_buf
->digest
;
12631 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12632 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12633 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12634 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12635 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12636 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12640 digest
[0] -= SHA384M_A
;
12641 digest
[1] -= SHA384M_B
;
12642 digest
[2] -= SHA384M_C
;
12643 digest
[3] -= SHA384M_D
;
12644 digest
[4] -= SHA384M_E
;
12645 digest
[5] -= SHA384M_F
;
12649 return (PARSER_OK
);
12652 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12654 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12656 u64
*digest
= (u64
*) hash_buf
->digest
;
12658 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12659 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12660 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12661 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12662 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12663 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12664 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12665 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12667 digest
[0] -= SHA512M_A
;
12668 digest
[1] -= SHA512M_B
;
12669 digest
[2] -= SHA512M_C
;
12670 digest
[3] -= SHA512M_D
;
12671 digest
[4] -= SHA512M_E
;
12672 digest
[5] -= SHA512M_F
;
12673 digest
[6] -= SHA512M_G
;
12674 digest
[7] -= SHA512M_H
;
12676 return (PARSER_OK
);
12679 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12681 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12683 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12687 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12690 u64
*digest
= (u64
*) hash_buf
->digest
;
12692 salt_t
*salt
= hash_buf
->salt
;
12694 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12695 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12696 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12697 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12698 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12699 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12700 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12701 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12703 digest
[0] -= SHA512M_A
;
12704 digest
[1] -= SHA512M_B
;
12705 digest
[2] -= SHA512M_C
;
12706 digest
[3] -= SHA512M_D
;
12707 digest
[4] -= SHA512M_E
;
12708 digest
[5] -= SHA512M_F
;
12709 digest
[6] -= SHA512M_G
;
12710 digest
[7] -= SHA512M_H
;
12712 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12714 uint salt_len
= input_len
- 128 - 1;
12716 char *salt_buf
= input_buf
+ 128 + 1;
12718 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12720 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12722 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12724 salt
->salt_len
= salt_len
;
12726 return (PARSER_OK
);
12729 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12731 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12733 u64
*digest
= (u64
*) hash_buf
->digest
;
12735 salt_t
*salt
= hash_buf
->salt
;
12737 char *salt_pos
= input_buf
+ 3;
12739 uint iterations_len
= 0;
12741 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12745 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12747 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12748 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12752 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12756 iterations_len
+= 8;
12760 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12763 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12765 char *hash_pos
= strchr (salt_pos
, '$');
12767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12769 uint salt_len
= hash_pos
- salt_pos
;
12771 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12773 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12775 salt
->salt_len
= salt_len
;
12779 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12781 return (PARSER_OK
);
12784 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12786 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12788 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12790 u64
*digest
= (u64
*) hash_buf
->digest
;
12792 salt_t
*salt
= hash_buf
->salt
;
12794 uint keccak_mdlen
= input_len
/ 2;
12796 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12798 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12800 digest
[i
] = byte_swap_64 (digest
[i
]);
12803 salt
->keccak_mdlen
= keccak_mdlen
;
12805 return (PARSER_OK
);
12808 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12810 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12812 u32
*digest
= (u32
*) hash_buf
->digest
;
12814 salt_t
*salt
= hash_buf
->salt
;
12816 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12819 * Parse that strange long line
12824 size_t in_len
[9] = { 0 };
12826 in_off
[0] = strtok (input_buf
, ":");
12828 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12830 in_len
[0] = strlen (in_off
[0]);
12834 for (i
= 1; i
< 9; i
++)
12836 in_off
[i
] = strtok (NULL
, ":");
12838 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12840 in_len
[i
] = strlen (in_off
[i
]);
12843 char *ptr
= (char *) ikepsk
->msg_buf
;
12845 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12846 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12847 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12848 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12849 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12850 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12854 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12856 ptr
= (char *) ikepsk
->nr_buf
;
12858 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12859 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12863 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12866 * Store to database
12871 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12872 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12873 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12874 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12876 digest
[0] = byte_swap_32 (digest
[0]);
12877 digest
[1] = byte_swap_32 (digest
[1]);
12878 digest
[2] = byte_swap_32 (digest
[2]);
12879 digest
[3] = byte_swap_32 (digest
[3]);
12881 salt
->salt_len
= 32;
12883 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12884 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12885 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12886 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12887 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12888 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12889 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12890 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12892 return (PARSER_OK
);
12895 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12897 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12899 u32
*digest
= (u32
*) hash_buf
->digest
;
12901 salt_t
*salt
= hash_buf
->salt
;
12903 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12906 * Parse that strange long line
12911 size_t in_len
[9] = { 0 };
12913 in_off
[0] = strtok (input_buf
, ":");
12915 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12917 in_len
[0] = strlen (in_off
[0]);
12921 for (i
= 1; i
< 9; i
++)
12923 in_off
[i
] = strtok (NULL
, ":");
12925 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12927 in_len
[i
] = strlen (in_off
[i
]);
12930 char *ptr
= (char *) ikepsk
->msg_buf
;
12932 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12933 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12934 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12935 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12936 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12937 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12941 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12943 ptr
= (char *) ikepsk
->nr_buf
;
12945 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12946 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12950 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12953 * Store to database
12958 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12959 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12960 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12961 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12962 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12964 salt
->salt_len
= 32;
12966 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12967 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12968 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12969 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12970 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12971 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12972 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12973 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12975 return (PARSER_OK
);
12978 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12980 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12982 u32
*digest
= (u32
*) hash_buf
->digest
;
12984 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12985 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12986 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12987 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12988 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12990 digest
[0] = byte_swap_32 (digest
[0]);
12991 digest
[1] = byte_swap_32 (digest
[1]);
12992 digest
[2] = byte_swap_32 (digest
[2]);
12993 digest
[3] = byte_swap_32 (digest
[3]);
12994 digest
[4] = byte_swap_32 (digest
[4]);
12996 return (PARSER_OK
);
12999 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13001 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
13003 u32
*digest
= (u32
*) hash_buf
->digest
;
13005 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13006 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13007 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
13008 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
13009 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
13010 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
13011 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
13012 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
13013 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
13014 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
13015 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
13016 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
13017 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
13018 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
13019 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
13020 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
13022 return (PARSER_OK
);
13025 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13027 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
13029 u32
*digest
= (u32
*) hash_buf
->digest
;
13031 salt_t
*salt
= hash_buf
->salt
;
13033 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13034 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13035 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13036 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13037 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13039 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13041 uint salt_len
= input_len
- 40 - 1;
13043 char *salt_buf
= input_buf
+ 40 + 1;
13045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13047 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13049 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13051 salt
->salt_len
= salt_len
;
13053 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
13055 return (PARSER_OK
);
13058 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13060 u32
*digest
= (u32
*) hash_buf
->digest
;
13062 salt_t
*salt
= hash_buf
->salt
;
13064 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13066 if (input_len
== 0)
13068 log_error ("TrueCrypt container not specified");
13073 FILE *fp
= fopen (input_buf
, "rb");
13077 log_error ("%s: %s", input_buf
, strerror (errno
));
13082 char buf
[512] = { 0 };
13084 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13088 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13090 memcpy (tc
->salt_buf
, buf
, 64);
13092 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13094 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13096 salt
->salt_len
= 4;
13098 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
13100 tc
->signature
= 0x45555254; // "TRUE"
13102 digest
[0] = tc
->data_buf
[0];
13104 return (PARSER_OK
);
13107 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13109 u32
*digest
= (u32
*) hash_buf
->digest
;
13111 salt_t
*salt
= hash_buf
->salt
;
13113 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13115 if (input_len
== 0)
13117 log_error ("TrueCrypt container not specified");
13122 FILE *fp
= fopen (input_buf
, "rb");
13126 log_error ("%s: %s", input_buf
, strerror (errno
));
13131 char buf
[512] = { 0 };
13133 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13137 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13139 memcpy (tc
->salt_buf
, buf
, 64);
13141 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13143 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13145 salt
->salt_len
= 4;
13147 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13149 tc
->signature
= 0x45555254; // "TRUE"
13151 digest
[0] = tc
->data_buf
[0];
13153 return (PARSER_OK
);
13156 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13158 u32
*digest
= (u32
*) hash_buf
->digest
;
13160 salt_t
*salt
= hash_buf
->salt
;
13162 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13164 if (input_len
== 0)
13166 log_error ("VeraCrypt container not specified");
13171 FILE *fp
= fopen (input_buf
, "rb");
13175 log_error ("%s: %s", input_buf
, strerror (errno
));
13180 char buf
[512] = { 0 };
13182 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13186 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13188 memcpy (tc
->salt_buf
, buf
, 64);
13190 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13192 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13194 salt
->salt_len
= 4;
13196 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13198 tc
->signature
= 0x41524556; // "VERA"
13200 digest
[0] = tc
->data_buf
[0];
13202 return (PARSER_OK
);
13205 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13207 u32
*digest
= (u32
*) hash_buf
->digest
;
13209 salt_t
*salt
= hash_buf
->salt
;
13211 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13213 if (input_len
== 0)
13215 log_error ("VeraCrypt container not specified");
13220 FILE *fp
= fopen (input_buf
, "rb");
13224 log_error ("%s: %s", input_buf
, strerror (errno
));
13229 char buf
[512] = { 0 };
13231 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13235 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13237 memcpy (tc
->salt_buf
, buf
, 64);
13239 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13241 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13243 salt
->salt_len
= 4;
13245 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13247 tc
->signature
= 0x41524556; // "VERA"
13249 digest
[0] = tc
->data_buf
[0];
13251 return (PARSER_OK
);
13254 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13256 u32
*digest
= (u32
*) hash_buf
->digest
;
13258 salt_t
*salt
= hash_buf
->salt
;
13260 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13262 if (input_len
== 0)
13264 log_error ("VeraCrypt container not specified");
13269 FILE *fp
= fopen (input_buf
, "rb");
13273 log_error ("%s: %s", input_buf
, strerror (errno
));
13278 char buf
[512] = { 0 };
13280 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13284 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13286 memcpy (tc
->salt_buf
, buf
, 64);
13288 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13290 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13292 salt
->salt_len
= 4;
13294 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13296 tc
->signature
= 0x41524556; // "VERA"
13298 digest
[0] = tc
->data_buf
[0];
13300 return (PARSER_OK
);
13303 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13305 u32
*digest
= (u32
*) hash_buf
->digest
;
13307 salt_t
*salt
= hash_buf
->salt
;
13309 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13311 if (input_len
== 0)
13313 log_error ("VeraCrypt container not specified");
13318 FILE *fp
= fopen (input_buf
, "rb");
13322 log_error ("%s: %s", input_buf
, strerror (errno
));
13327 char buf
[512] = { 0 };
13329 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13333 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13335 memcpy (tc
->salt_buf
, buf
, 64);
13337 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13339 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13341 salt
->salt_len
= 4;
13343 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13345 tc
->signature
= 0x41524556; // "VERA"
13347 digest
[0] = tc
->data_buf
[0];
13349 return (PARSER_OK
);
13352 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13354 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13356 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13358 u32
*digest
= (u32
*) hash_buf
->digest
;
13360 salt_t
*salt
= hash_buf
->salt
;
13362 char *salt_pos
= input_buf
+ 6;
13364 char *hash_pos
= strchr (salt_pos
, '$');
13366 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13368 uint salt_len
= hash_pos
- salt_pos
;
13370 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13372 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13374 salt
->salt_len
= salt_len
;
13376 salt
->salt_iter
= 1000;
13380 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13382 return (PARSER_OK
);
13385 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13387 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13389 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13391 u32
*digest
= (u32
*) hash_buf
->digest
;
13393 salt_t
*salt
= hash_buf
->salt
;
13395 char *iter_pos
= input_buf
+ 7;
13397 char *salt_pos
= strchr (iter_pos
, '$');
13399 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13403 char *hash_pos
= strchr (salt_pos
, '$');
13405 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13407 uint salt_len
= hash_pos
- salt_pos
;
13409 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13411 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13413 salt
->salt_len
= salt_len
;
13415 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13417 salt
->salt_sign
[0] = atoi (salt_iter
);
13419 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13423 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13425 digest
[0] = byte_swap_32 (digest
[0]);
13426 digest
[1] = byte_swap_32 (digest
[1]);
13427 digest
[2] = byte_swap_32 (digest
[2]);
13428 digest
[3] = byte_swap_32 (digest
[3]);
13429 digest
[4] = byte_swap_32 (digest
[4]);
13431 return (PARSER_OK
);
13434 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13436 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13438 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13440 u32
*digest
= (u32
*) hash_buf
->digest
;
13442 salt_t
*salt
= hash_buf
->salt
;
13444 char *iter_pos
= input_buf
+ 9;
13446 char *salt_pos
= strchr (iter_pos
, '$');
13448 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13452 char *hash_pos
= strchr (salt_pos
, '$');
13454 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13456 uint salt_len
= hash_pos
- salt_pos
;
13458 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13460 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13462 salt
->salt_len
= salt_len
;
13464 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13466 salt
->salt_sign
[0] = atoi (salt_iter
);
13468 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13472 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13474 digest
[0] = byte_swap_32 (digest
[0]);
13475 digest
[1] = byte_swap_32 (digest
[1]);
13476 digest
[2] = byte_swap_32 (digest
[2]);
13477 digest
[3] = byte_swap_32 (digest
[3]);
13478 digest
[4] = byte_swap_32 (digest
[4]);
13479 digest
[5] = byte_swap_32 (digest
[5]);
13480 digest
[6] = byte_swap_32 (digest
[6]);
13481 digest
[7] = byte_swap_32 (digest
[7]);
13483 return (PARSER_OK
);
13486 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13488 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13490 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13492 u64
*digest
= (u64
*) hash_buf
->digest
;
13494 salt_t
*salt
= hash_buf
->salt
;
13496 char *iter_pos
= input_buf
+ 9;
13498 char *salt_pos
= strchr (iter_pos
, '$');
13500 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13504 char *hash_pos
= strchr (salt_pos
, '$');
13506 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13508 uint salt_len
= hash_pos
- salt_pos
;
13510 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13512 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13514 salt
->salt_len
= salt_len
;
13516 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13518 salt
->salt_sign
[0] = atoi (salt_iter
);
13520 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13524 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13526 digest
[0] = byte_swap_64 (digest
[0]);
13527 digest
[1] = byte_swap_64 (digest
[1]);
13528 digest
[2] = byte_swap_64 (digest
[2]);
13529 digest
[3] = byte_swap_64 (digest
[3]);
13530 digest
[4] = byte_swap_64 (digest
[4]);
13531 digest
[5] = byte_swap_64 (digest
[5]);
13532 digest
[6] = byte_swap_64 (digest
[6]);
13533 digest
[7] = byte_swap_64 (digest
[7]);
13535 return (PARSER_OK
);
13538 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13540 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13542 u32
*digest
= (u32
*) hash_buf
->digest
;
13544 salt_t
*salt
= hash_buf
->salt
;
13546 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13552 char *iterations_pos
= input_buf
;
13554 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13556 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13558 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13560 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13564 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13566 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13568 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13570 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13572 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13574 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13579 * pbkdf2 iterations
13582 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13585 * handle salt encoding
13588 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13590 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13592 const char p0
= saltbuf_pos
[i
+ 0];
13593 const char p1
= saltbuf_pos
[i
+ 1];
13595 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13596 | hex_convert (p0
) << 4;
13599 salt
->salt_len
= saltbuf_len
/ 2;
13602 * handle cipher encoding
13605 uint
*tmp
= (uint
*) mymalloc (32);
13607 char *cipherbuf_ptr
= (char *) tmp
;
13609 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13611 const char p0
= cipherbuf_pos
[i
+ 0];
13612 const char p1
= cipherbuf_pos
[i
+ 1];
13614 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13615 | hex_convert (p0
) << 4;
13618 // iv is stored at salt_buf 4 (length 16)
13619 // data is stored at salt_buf 8 (length 16)
13621 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13622 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13623 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13624 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13626 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13627 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13628 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13629 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13633 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13635 const char p0
= cipherbuf_pos
[j
+ 0];
13636 const char p1
= cipherbuf_pos
[j
+ 1];
13638 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13639 | hex_convert (p0
) << 4;
13646 digest
[0] = 0x10101010;
13647 digest
[1] = 0x10101010;
13648 digest
[2] = 0x10101010;
13649 digest
[3] = 0x10101010;
13651 return (PARSER_OK
);
13654 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13656 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13658 u32
*digest
= (u32
*) hash_buf
->digest
;
13660 salt_t
*salt
= hash_buf
->salt
;
13662 char *hashbuf_pos
= input_buf
;
13664 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13666 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13668 uint hash_len
= iterations_pos
- hashbuf_pos
;
13670 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13674 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13676 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13678 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13682 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13684 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13686 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13688 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13690 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13692 salt
->salt_len
= salt_len
;
13694 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13696 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13697 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13698 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13699 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13701 return (PARSER_OK
);
13704 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13706 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13708 u32
*digest
= (u32
*) hash_buf
->digest
;
13710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13714 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13715 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13716 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13717 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13719 digest
[0] = byte_swap_32 (digest
[0]);
13720 digest
[1] = byte_swap_32 (digest
[1]);
13721 digest
[2] = byte_swap_32 (digest
[2]);
13722 digest
[3] = byte_swap_32 (digest
[3]);
13723 digest
[4] = byte_swap_32 (digest
[4]);
13724 digest
[5] = byte_swap_32 (digest
[5]);
13725 digest
[6] = byte_swap_32 (digest
[6]);
13726 digest
[7] = byte_swap_32 (digest
[7]);
13728 return (PARSER_OK
);
13731 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13733 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13735 u32
*digest
= (u32
*) hash_buf
->digest
;
13737 salt_t
*salt
= hash_buf
->salt
;
13739 char *salt_pos
= input_buf
+ 3;
13741 uint iterations_len
= 0;
13743 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13747 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13749 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13750 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13754 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13758 iterations_len
+= 8;
13762 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13765 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13767 char *hash_pos
= strchr (salt_pos
, '$');
13769 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13771 uint salt_len
= hash_pos
- salt_pos
;
13773 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13775 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13777 salt
->salt_len
= salt_len
;
13781 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13783 return (PARSER_OK
);
13786 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13788 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13790 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13792 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13794 u64
*digest
= (u64
*) hash_buf
->digest
;
13796 salt_t
*salt
= hash_buf
->salt
;
13798 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13800 char *iter_pos
= input_buf
+ 4;
13802 char *salt_pos
= strchr (iter_pos
, '$');
13804 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13808 char *hash_pos
= strchr (salt_pos
, '$');
13810 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13812 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13816 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13817 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13818 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13819 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13820 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13821 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13822 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13823 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13825 uint salt_len
= hash_pos
- salt_pos
- 1;
13827 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13829 salt
->salt_len
= salt_len
/ 2;
13831 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13832 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13833 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13834 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13835 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13836 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13837 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13838 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13840 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13841 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13842 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13843 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13844 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13845 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13846 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13847 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13848 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13849 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13851 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13853 salt
->salt_iter
= atoi (iter_pos
) - 1;
13855 return (PARSER_OK
);
13858 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13860 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13862 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13864 u32
*digest
= (u32
*) hash_buf
->digest
;
13866 salt_t
*salt
= hash_buf
->salt
;
13868 char *salt_pos
= input_buf
+ 14;
13870 char *hash_pos
= strchr (salt_pos
, '*');
13872 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13876 uint salt_len
= hash_pos
- salt_pos
- 1;
13878 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13880 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13882 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13884 salt
->salt_len
= salt_len
;
13886 u8 tmp_buf
[100] = { 0 };
13888 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13890 memcpy (digest
, tmp_buf
, 32);
13892 digest
[0] = byte_swap_32 (digest
[0]);
13893 digest
[1] = byte_swap_32 (digest
[1]);
13894 digest
[2] = byte_swap_32 (digest
[2]);
13895 digest
[3] = byte_swap_32 (digest
[3]);
13896 digest
[4] = byte_swap_32 (digest
[4]);
13897 digest
[5] = byte_swap_32 (digest
[5]);
13898 digest
[6] = byte_swap_32 (digest
[6]);
13899 digest
[7] = byte_swap_32 (digest
[7]);
13901 digest
[0] -= SHA256M_A
;
13902 digest
[1] -= SHA256M_B
;
13903 digest
[2] -= SHA256M_C
;
13904 digest
[3] -= SHA256M_D
;
13905 digest
[4] -= SHA256M_E
;
13906 digest
[5] -= SHA256M_F
;
13907 digest
[6] -= SHA256M_G
;
13908 digest
[7] -= SHA256M_H
;
13910 return (PARSER_OK
);
13913 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13915 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13917 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13919 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13921 u64
*digest
= (u64
*) hash_buf
->digest
;
13923 salt_t
*salt
= hash_buf
->salt
;
13925 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13927 char *iter_pos
= input_buf
+ 19;
13929 char *salt_pos
= strchr (iter_pos
, '.');
13931 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13935 char *hash_pos
= strchr (salt_pos
, '.');
13937 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13939 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13943 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13944 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13945 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13946 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13947 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13948 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13949 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13950 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13952 uint salt_len
= hash_pos
- salt_pos
- 1;
13956 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13960 for (i
= 0; i
< salt_len
; i
++)
13962 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13965 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13966 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13968 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13970 salt
->salt_len
= salt_len
;
13972 salt
->salt_iter
= atoi (iter_pos
) - 1;
13974 return (PARSER_OK
);
13977 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13979 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13981 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13983 u64
*digest
= (u64
*) hash_buf
->digest
;
13985 salt_t
*salt
= hash_buf
->salt
;
13987 u8 tmp_buf
[120] = { 0 };
13989 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13991 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13993 memcpy (digest
, tmp_buf
, 64);
13995 digest
[0] = byte_swap_64 (digest
[0]);
13996 digest
[1] = byte_swap_64 (digest
[1]);
13997 digest
[2] = byte_swap_64 (digest
[2]);
13998 digest
[3] = byte_swap_64 (digest
[3]);
13999 digest
[4] = byte_swap_64 (digest
[4]);
14000 digest
[5] = byte_swap_64 (digest
[5]);
14001 digest
[6] = byte_swap_64 (digest
[6]);
14002 digest
[7] = byte_swap_64 (digest
[7]);
14004 digest
[0] -= SHA512M_A
;
14005 digest
[1] -= SHA512M_B
;
14006 digest
[2] -= SHA512M_C
;
14007 digest
[3] -= SHA512M_D
;
14008 digest
[4] -= SHA512M_E
;
14009 digest
[5] -= SHA512M_F
;
14010 digest
[6] -= SHA512M_G
;
14011 digest
[7] -= SHA512M_H
;
14013 int salt_len
= tmp_len
- 64;
14015 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
14017 salt
->salt_len
= salt_len
;
14019 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
14021 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
14023 char *ptr
= (char *) salt
->salt_buf
;
14025 ptr
[salt
->salt_len
] = 0x80;
14028 return (PARSER_OK
);
14031 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14033 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14035 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
14039 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
14042 u32
*digest
= (u32
*) hash_buf
->digest
;
14044 salt_t
*salt
= hash_buf
->salt
;
14046 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14047 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14048 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14049 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14051 digest
[0] = byte_swap_32 (digest
[0]);
14052 digest
[1] = byte_swap_32 (digest
[1]);
14053 digest
[2] = byte_swap_32 (digest
[2]);
14054 digest
[3] = byte_swap_32 (digest
[3]);
14056 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14058 uint salt_len
= input_len
- 32 - 1;
14060 char *salt_buf
= input_buf
+ 32 + 1;
14062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14064 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14066 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14068 salt
->salt_len
= salt_len
;
14070 return (PARSER_OK
);
14073 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14075 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14077 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
14081 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
14084 u32
*digest
= (u32
*) hash_buf
->digest
;
14086 salt_t
*salt
= hash_buf
->salt
;
14088 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14089 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14090 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14091 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14092 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14094 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14096 uint salt_len
= input_len
- 40 - 1;
14098 char *salt_buf
= input_buf
+ 40 + 1;
14100 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14102 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14104 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14106 salt
->salt_len
= salt_len
;
14108 return (PARSER_OK
);
14111 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14113 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14115 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
14119 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
14122 u32
*digest
= (u32
*) hash_buf
->digest
;
14124 salt_t
*salt
= hash_buf
->salt
;
14126 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14127 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14128 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14129 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14130 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14131 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14132 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14133 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14135 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14137 uint salt_len
= input_len
- 64 - 1;
14139 char *salt_buf
= input_buf
+ 64 + 1;
14141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14143 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14147 salt
->salt_len
= salt_len
;
14149 return (PARSER_OK
);
14152 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14154 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14156 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14160 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14163 u64
*digest
= (u64
*) hash_buf
->digest
;
14165 salt_t
*salt
= hash_buf
->salt
;
14167 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14168 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14169 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14170 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14171 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14172 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14173 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14174 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14176 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14178 uint salt_len
= input_len
- 128 - 1;
14180 char *salt_buf
= input_buf
+ 128 + 1;
14182 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14184 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14186 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14188 salt
->salt_len
= salt_len
;
14190 return (PARSER_OK
);
14193 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14195 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14197 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14199 u32
*digest
= (u32
*) hash_buf
->digest
;
14201 salt_t
*salt
= hash_buf
->salt
;
14203 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14209 char *user_pos
= input_buf
+ 10 + 1;
14211 char *realm_pos
= strchr (user_pos
, '$');
14213 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14215 uint user_len
= realm_pos
- user_pos
;
14217 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14221 char *salt_pos
= strchr (realm_pos
, '$');
14223 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14225 uint realm_len
= salt_pos
- realm_pos
;
14227 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14231 char *data_pos
= strchr (salt_pos
, '$');
14233 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14235 uint salt_len
= data_pos
- salt_pos
;
14237 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14241 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14243 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14249 memcpy (krb5pa
->user
, user_pos
, user_len
);
14250 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14251 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14253 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14255 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14257 const char p0
= data_pos
[i
+ 0];
14258 const char p1
= data_pos
[i
+ 1];
14260 *timestamp_ptr
++ = hex_convert (p1
) << 0
14261 | hex_convert (p0
) << 4;
14264 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14266 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14268 const char p0
= data_pos
[i
+ 0];
14269 const char p1
= data_pos
[i
+ 1];
14271 *checksum_ptr
++ = hex_convert (p1
) << 0
14272 | hex_convert (p0
) << 4;
14276 * copy some data to generic buffers to make sorting happy
14279 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14280 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14281 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14282 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14283 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14284 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14285 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14286 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14287 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14289 salt
->salt_len
= 36;
14291 digest
[0] = krb5pa
->checksum
[0];
14292 digest
[1] = krb5pa
->checksum
[1];
14293 digest
[2] = krb5pa
->checksum
[2];
14294 digest
[3] = krb5pa
->checksum
[3];
14296 return (PARSER_OK
);
14299 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14301 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14303 u32
*digest
= (u32
*) hash_buf
->digest
;
14305 salt_t
*salt
= hash_buf
->salt
;
14311 char *salt_pos
= input_buf
;
14313 char *hash_pos
= strchr (salt_pos
, '$');
14315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14317 uint salt_len
= hash_pos
- salt_pos
;
14319 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14323 uint hash_len
= input_len
- 1 - salt_len
;
14325 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14333 for (uint i
= 0; i
< salt_len
; i
++)
14335 if (salt_pos
[i
] == ' ') continue;
14340 // SAP user names cannot be longer than 12 characters
14341 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14343 // SAP user name cannot start with ! or ?
14344 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14350 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14352 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14354 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14356 salt
->salt_len
= salt_len
;
14358 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14359 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14363 digest
[0] = byte_swap_32 (digest
[0]);
14364 digest
[1] = byte_swap_32 (digest
[1]);
14366 return (PARSER_OK
);
14369 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14371 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14373 u32
*digest
= (u32
*) hash_buf
->digest
;
14375 salt_t
*salt
= hash_buf
->salt
;
14381 char *salt_pos
= input_buf
;
14383 char *hash_pos
= strchr (salt_pos
, '$');
14385 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14387 uint salt_len
= hash_pos
- salt_pos
;
14389 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14393 uint hash_len
= input_len
- 1 - salt_len
;
14395 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14403 for (uint i
= 0; i
< salt_len
; i
++)
14405 if (salt_pos
[i
] == ' ') continue;
14410 // SAP user names cannot be longer than 12 characters
14411 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14412 // so far nobody complained so we stay with this because it helps in optimization
14413 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14415 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14417 // SAP user name cannot start with ! or ?
14418 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14426 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14430 salt
->salt_len
= salt_len
;
14432 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14433 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14434 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14435 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14436 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14438 return (PARSER_OK
);
14441 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14443 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14445 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14447 u64
*digest
= (u64
*) hash_buf
->digest
;
14449 salt_t
*salt
= hash_buf
->salt
;
14451 char *iter_pos
= input_buf
+ 3;
14453 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14455 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14457 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14459 salt
->salt_iter
= salt_iter
;
14461 char *salt_pos
= iter_pos
+ 1;
14465 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14467 salt
->salt_len
= salt_len
;
14469 char *hash_pos
= salt_pos
+ salt_len
;
14471 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14475 char *tmp
= (char *) salt
->salt_buf_pc
;
14477 tmp
[0] = hash_pos
[42];
14481 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14482 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14483 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14484 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14490 return (PARSER_OK
);
14493 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14495 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14497 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14499 u32
*digest
= (u32
*) hash_buf
->digest
;
14501 salt_t
*salt
= hash_buf
->salt
;
14503 char *salt_buf
= input_buf
+ 6;
14505 uint salt_len
= 16;
14507 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14509 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14511 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14513 salt
->salt_len
= salt_len
;
14515 char *hash_pos
= input_buf
+ 6 + 16;
14517 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14518 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14519 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14520 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14521 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14522 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14523 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14524 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14526 return (PARSER_OK
);
14529 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14531 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14533 u32
*digest
= (u32
*) hash_buf
->digest
;
14535 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14536 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14540 return (PARSER_OK
);
14543 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14545 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14547 u32
*digest
= (u32
*) hash_buf
->digest
;
14549 salt_t
*salt
= hash_buf
->salt
;
14551 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14553 char *saltbuf_pos
= input_buf
;
14555 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14557 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14559 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14561 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14562 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14564 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14568 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14570 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14572 char *salt_ptr
= (char *) saltbuf_pos
;
14573 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14578 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14580 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14583 rakp_ptr
[j
] = 0x80;
14585 rakp
->salt_len
= j
;
14587 for (i
= 0; i
< 64; i
++)
14589 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14592 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14593 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14594 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14595 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14596 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14597 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14598 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14599 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14601 salt
->salt_len
= 32; // muss min. 32 haben
14603 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14604 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14605 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14606 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14607 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14609 return (PARSER_OK
);
14612 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14614 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14616 u32
*digest
= (u32
*) hash_buf
->digest
;
14618 salt_t
*salt
= hash_buf
->salt
;
14620 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14622 char *salt_pos
= input_buf
+ 1;
14624 memcpy (salt
->salt_buf
, salt_pos
, 8);
14626 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14627 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14629 salt
->salt_len
= 8;
14631 char *hash_pos
= salt_pos
+ 8;
14633 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14634 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14635 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14636 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14637 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14639 digest
[0] -= SHA1M_A
;
14640 digest
[1] -= SHA1M_B
;
14641 digest
[2] -= SHA1M_C
;
14642 digest
[3] -= SHA1M_D
;
14643 digest
[4] -= SHA1M_E
;
14645 return (PARSER_OK
);
14648 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14650 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14652 u32
*digest
= (u32
*) hash_buf
->digest
;
14654 salt_t
*salt
= hash_buf
->salt
;
14656 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14657 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14658 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14659 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14661 digest
[0] = byte_swap_32 (digest
[0]);
14662 digest
[1] = byte_swap_32 (digest
[1]);
14663 digest
[2] = byte_swap_32 (digest
[2]);
14664 digest
[3] = byte_swap_32 (digest
[3]);
14666 digest
[0] -= MD5M_A
;
14667 digest
[1] -= MD5M_B
;
14668 digest
[2] -= MD5M_C
;
14669 digest
[3] -= MD5M_D
;
14671 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14673 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14675 u32
*salt_buf
= salt
->salt_buf
;
14677 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14678 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14679 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14680 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14682 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14683 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14684 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14685 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14687 salt
->salt_len
= 16 + 1;
14689 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14691 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14693 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14695 return (PARSER_OK
);
14698 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14700 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14702 u32
*digest
= (u32
*) hash_buf
->digest
;
14704 salt_t
*salt
= hash_buf
->salt
;
14706 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14712 char *hashbuf_pos
= input_buf
;
14714 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14716 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14718 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14720 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14724 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14726 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14728 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14730 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14734 char *databuf_pos
= strchr (iteration_pos
, ':');
14736 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14738 const uint iteration_len
= databuf_pos
- iteration_pos
;
14740 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14741 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14743 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14745 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14746 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14752 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14753 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14754 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14755 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14756 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14757 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14758 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14759 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14763 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14765 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14767 const char p0
= saltbuf_pos
[i
+ 0];
14768 const char p1
= saltbuf_pos
[i
+ 1];
14770 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14771 | hex_convert (p0
) << 4;
14774 salt
->salt_buf
[4] = 0x01000000;
14775 salt
->salt_buf
[5] = 0x80;
14777 salt
->salt_len
= saltbuf_len
/ 2;
14781 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14785 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14787 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14789 const char p0
= databuf_pos
[i
+ 0];
14790 const char p1
= databuf_pos
[i
+ 1];
14792 *databuf_ptr
++ = hex_convert (p1
) << 0
14793 | hex_convert (p0
) << 4;
14796 *databuf_ptr
++ = 0x80;
14798 for (uint i
= 0; i
< 512; i
++)
14800 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14803 cloudkey
->data_len
= databuf_len
/ 2;
14805 return (PARSER_OK
);
14808 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14810 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14812 u32
*digest
= (u32
*) hash_buf
->digest
;
14814 salt_t
*salt
= hash_buf
->salt
;
14820 char *hashbuf_pos
= input_buf
;
14822 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14824 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14826 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14828 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14832 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14834 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14836 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14838 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14840 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14844 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14846 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14848 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14850 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14852 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14856 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14858 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14859 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14861 // ok, the plan for this algorithm is the following:
14862 // we have 2 salts here, the domain-name and a random salt
14863 // while both are used in the initial transformation,
14864 // only the random salt is used in the following iterations
14865 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14866 // and one that includes only the real salt (stored into salt_buf[]).
14867 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14869 u8 tmp_buf
[100] = { 0 };
14871 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14873 memcpy (digest
, tmp_buf
, 20);
14875 digest
[0] = byte_swap_32 (digest
[0]);
14876 digest
[1] = byte_swap_32 (digest
[1]);
14877 digest
[2] = byte_swap_32 (digest
[2]);
14878 digest
[3] = byte_swap_32 (digest
[3]);
14879 digest
[4] = byte_swap_32 (digest
[4]);
14883 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14885 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14887 char *len_ptr
= NULL
;
14889 for (uint i
= 0; i
< domainbuf_len
; i
++)
14891 if (salt_buf_pc_ptr
[i
] == '.')
14893 len_ptr
= &salt_buf_pc_ptr
[i
];
14903 salt
->salt_buf_pc
[7] = domainbuf_len
;
14907 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14909 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14911 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14913 salt
->salt_len
= salt_len
;
14917 salt
->salt_iter
= atoi (iteration_pos
);
14919 return (PARSER_OK
);
14922 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14924 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14926 u32
*digest
= (u32
*) hash_buf
->digest
;
14928 salt_t
*salt
= hash_buf
->salt
;
14930 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14931 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14932 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14933 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14934 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14936 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14938 uint salt_len
= input_len
- 40 - 1;
14940 char *salt_buf
= input_buf
+ 40 + 1;
14942 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14944 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14946 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14948 salt
->salt_len
= salt_len
;
14950 return (PARSER_OK
);
14953 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14955 const u8 ascii_to_ebcdic
[] =
14957 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14958 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14959 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14960 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14961 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14962 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14963 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14964 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14965 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14966 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14967 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14968 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14969 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14970 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14971 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14972 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14975 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14977 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14979 u32
*digest
= (u32
*) hash_buf
->digest
;
14981 salt_t
*salt
= hash_buf
->salt
;
14983 char *salt_pos
= input_buf
+ 6 + 1;
14985 char *digest_pos
= strchr (salt_pos
, '*');
14987 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14989 uint salt_len
= digest_pos
- salt_pos
;
14991 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14993 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14995 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14999 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15000 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
15002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
15004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15006 salt
->salt_len
= salt_len
;
15008 for (uint i
= 0; i
< salt_len
; i
++)
15010 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
15012 for (uint i
= salt_len
; i
< 8; i
++)
15014 salt_buf_pc_ptr
[i
] = 0x40;
15019 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
15021 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
15022 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
15024 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
15025 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
15027 digest
[0] = byte_swap_32 (digest
[0]);
15028 digest
[1] = byte_swap_32 (digest
[1]);
15030 IP (digest
[0], digest
[1], tt
);
15032 digest
[0] = rotr32 (digest
[0], 29);
15033 digest
[1] = rotr32 (digest
[1], 29);
15037 return (PARSER_OK
);
15040 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15042 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
15044 u32
*digest
= (u32
*) hash_buf
->digest
;
15046 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15047 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15048 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15049 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15051 digest
[0] = byte_swap_32 (digest
[0]);
15052 digest
[1] = byte_swap_32 (digest
[1]);
15053 digest
[2] = byte_swap_32 (digest
[2]);
15054 digest
[3] = byte_swap_32 (digest
[3]);
15056 return (PARSER_OK
);
15059 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15061 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
15063 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15065 u32
*digest
= (u32
*) hash_buf
->digest
;
15067 salt_t
*salt
= hash_buf
->salt
;
15069 u8 tmp_buf
[120] = { 0 };
15071 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15073 tmp_buf
[3] += -4; // dont ask!
15075 memcpy (salt
->salt_buf
, tmp_buf
, 5);
15077 salt
->salt_len
= 5;
15079 memcpy (digest
, tmp_buf
+ 5, 9);
15081 // yes, only 9 byte are needed to crack, but 10 to display
15083 salt
->salt_buf_pc
[7] = input_buf
[20];
15085 return (PARSER_OK
);
15088 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15090 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
15092 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
15094 u32
*digest
= (u32
*) hash_buf
->digest
;
15096 salt_t
*salt
= hash_buf
->salt
;
15098 u8 tmp_buf
[120] = { 0 };
15100 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
15102 tmp_buf
[3] += -4; // dont ask!
15106 memcpy (salt
->salt_buf
, tmp_buf
, 16);
15108 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)
15112 char tmp_iter_buf
[11] = { 0 };
15114 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
15116 tmp_iter_buf
[10] = 0;
15118 salt
->salt_iter
= atoi (tmp_iter_buf
);
15120 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
15122 return (PARSER_SALT_ITERATION
);
15125 salt
->salt_iter
--; // first round in init
15127 // 2 additional bytes for display only
15129 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15130 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15134 memcpy (digest
, tmp_buf
+ 28, 8);
15136 digest
[0] = byte_swap_32 (digest
[0]);
15137 digest
[1] = byte_swap_32 (digest
[1]);
15141 return (PARSER_OK
);
15144 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15146 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15148 u32
*digest
= (u32
*) hash_buf
->digest
;
15150 salt_t
*salt
= hash_buf
->salt
;
15152 char *salt_buf_pos
= input_buf
;
15154 char *hash_buf_pos
= salt_buf_pos
+ 6;
15156 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15157 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15158 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15159 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15160 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15161 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15162 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15163 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15165 digest
[0] -= SHA256M_A
;
15166 digest
[1] -= SHA256M_B
;
15167 digest
[2] -= SHA256M_C
;
15168 digest
[3] -= SHA256M_D
;
15169 digest
[4] -= SHA256M_E
;
15170 digest
[5] -= SHA256M_F
;
15171 digest
[6] -= SHA256M_G
;
15172 digest
[7] -= SHA256M_H
;
15174 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15176 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15178 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15180 salt
->salt_len
= salt_len
;
15182 return (PARSER_OK
);
15185 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15187 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15189 u32
*digest
= (u32
*) hash_buf
->digest
;
15191 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15193 salt_t
*salt
= hash_buf
->salt
;
15195 char *salt_buf
= input_buf
+ 6;
15197 char *digest_buf
= strchr (salt_buf
, '$');
15199 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15201 uint salt_len
= digest_buf
- salt_buf
;
15203 digest_buf
++; // skip the '$' symbol
15205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15211 salt
->salt_len
= salt_len
;
15213 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15214 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15215 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15216 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15218 digest
[0] = byte_swap_32 (digest
[0]);
15219 digest
[1] = byte_swap_32 (digest
[1]);
15220 digest
[2] = byte_swap_32 (digest
[2]);
15221 digest
[3] = byte_swap_32 (digest
[3]);
15223 digest
[0] -= MD5M_A
;
15224 digest
[1] -= MD5M_B
;
15225 digest
[2] -= MD5M_C
;
15226 digest
[3] -= MD5M_D
;
15228 return (PARSER_OK
);
15231 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15233 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15235 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15237 u32
*digest
= (u32
*) hash_buf
->digest
;
15239 salt_t
*salt
= hash_buf
->salt
;
15241 char *salt_buf
= input_buf
+ 3;
15243 char *digest_buf
= strchr (salt_buf
, '$');
15245 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15247 uint salt_len
= digest_buf
- salt_buf
;
15249 digest_buf
++; // skip the '$' symbol
15251 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15253 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15255 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15257 salt_buf_ptr
[salt_len
] = 0x2d;
15259 salt
->salt_len
= salt_len
+ 1;
15261 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15262 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15263 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15264 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15266 digest
[0] = byte_swap_32 (digest
[0]);
15267 digest
[1] = byte_swap_32 (digest
[1]);
15268 digest
[2] = byte_swap_32 (digest
[2]);
15269 digest
[3] = byte_swap_32 (digest
[3]);
15271 digest
[0] -= MD5M_A
;
15272 digest
[1] -= MD5M_B
;
15273 digest
[2] -= MD5M_C
;
15274 digest
[3] -= MD5M_D
;
15276 return (PARSER_OK
);
15279 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15281 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15283 u32
*digest
= (u32
*) hash_buf
->digest
;
15285 salt_t
*salt
= hash_buf
->salt
;
15287 u8 tmp_buf
[100] = { 0 };
15289 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15291 memcpy (digest
, tmp_buf
, 20);
15293 digest
[0] = byte_swap_32 (digest
[0]);
15294 digest
[1] = byte_swap_32 (digest
[1]);
15295 digest
[2] = byte_swap_32 (digest
[2]);
15296 digest
[3] = byte_swap_32 (digest
[3]);
15297 digest
[4] = byte_swap_32 (digest
[4]);
15299 digest
[0] -= SHA1M_A
;
15300 digest
[1] -= SHA1M_B
;
15301 digest
[2] -= SHA1M_C
;
15302 digest
[3] -= SHA1M_D
;
15303 digest
[4] -= SHA1M_E
;
15305 salt
->salt_buf
[0] = 0x80;
15307 salt
->salt_len
= 0;
15309 return (PARSER_OK
);
15312 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15314 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15316 u32
*digest
= (u32
*) hash_buf
->digest
;
15318 salt_t
*salt
= hash_buf
->salt
;
15320 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15321 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15322 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15323 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15325 digest
[0] = byte_swap_32 (digest
[0]);
15326 digest
[1] = byte_swap_32 (digest
[1]);
15327 digest
[2] = byte_swap_32 (digest
[2]);
15328 digest
[3] = byte_swap_32 (digest
[3]);
15330 digest
[0] -= MD5M_A
;
15331 digest
[1] -= MD5M_B
;
15332 digest
[2] -= MD5M_C
;
15333 digest
[3] -= MD5M_D
;
15335 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15337 uint salt_len
= input_len
- 32 - 1;
15339 char *salt_buf
= input_buf
+ 32 + 1;
15341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15348 * add static "salt" part
15351 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15355 salt
->salt_len
= salt_len
;
15357 return (PARSER_OK
);
15360 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15362 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15364 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15366 u32
*digest
= (u32
*) hash_buf
->digest
;
15368 salt_t
*salt
= hash_buf
->salt
;
15370 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15376 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15378 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15380 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15382 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15384 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15388 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15390 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15392 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15394 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15398 char *keybuf_pos
= strchr (keylen_pos
, '$');
15400 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15402 uint keylen_len
= keybuf_pos
- keylen_pos
;
15404 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15408 char *databuf_pos
= strchr (keybuf_pos
, '$');
15410 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15414 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15418 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15420 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15426 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15427 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15428 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15429 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15431 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15432 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15433 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15434 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15436 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15437 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15438 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15439 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15441 salt
->salt_len
= 16;
15442 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15444 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15446 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15449 return (PARSER_OK
);
15452 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15454 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15456 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15458 u32
*digest
= (u32
*) hash_buf
->digest
;
15460 salt_t
*salt
= hash_buf
->salt
;
15466 // first is the N salt parameter
15468 char *N_pos
= input_buf
+ 6;
15470 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15474 salt
->scrypt_N
= atoi (N_pos
);
15478 char *r_pos
= strchr (N_pos
, ':');
15480 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15484 salt
->scrypt_r
= atoi (r_pos
);
15488 char *p_pos
= strchr (r_pos
, ':');
15490 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15494 salt
->scrypt_p
= atoi (p_pos
);
15498 char *saltbuf_pos
= strchr (p_pos
, ':');
15500 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15504 char *hash_pos
= strchr (saltbuf_pos
, ':');
15506 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15512 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15514 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15516 u8 tmp_buf
[33] = { 0 };
15518 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15520 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15522 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15524 salt
->salt_len
= tmp_len
;
15525 salt
->salt_iter
= 1;
15527 // digest - base64 decode
15529 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15531 tmp_len
= input_len
- (hash_pos
- input_buf
);
15533 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15535 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15537 memcpy (digest
, tmp_buf
, 32);
15539 return (PARSER_OK
);
15542 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15544 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15546 u32
*digest
= (u32
*) hash_buf
->digest
;
15548 salt_t
*salt
= hash_buf
->salt
;
15554 char decrypted
[76] = { 0 }; // iv + hash
15556 juniper_decrypt_hash (input_buf
, decrypted
);
15558 char *md5crypt_hash
= decrypted
+ 12;
15560 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15562 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15564 char *salt_pos
= md5crypt_hash
+ 3;
15566 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15568 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15570 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15574 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15576 return (PARSER_OK
);
15579 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15581 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15583 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15585 u32
*digest
= (u32
*) hash_buf
->digest
;
15587 salt_t
*salt
= hash_buf
->salt
;
15589 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15595 // first is *raw* salt
15597 char *salt_pos
= input_buf
+ 3;
15599 char *hash_pos
= strchr (salt_pos
, '$');
15601 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15603 uint salt_len
= hash_pos
- salt_pos
;
15605 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15609 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15611 memcpy (salt_buf_ptr
, salt_pos
, 14);
15613 salt_buf_ptr
[17] = 0x01;
15614 salt_buf_ptr
[18] = 0x80;
15616 // add some stuff to normal salt to make sorted happy
15618 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15619 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15620 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15621 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15623 salt
->salt_len
= salt_len
;
15624 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15626 // base64 decode hash
15628 u8 tmp_buf
[100] = { 0 };
15630 uint hash_len
= input_len
- 3 - salt_len
- 1;
15632 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15634 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15636 memcpy (digest
, tmp_buf
, 32);
15638 digest
[0] = byte_swap_32 (digest
[0]);
15639 digest
[1] = byte_swap_32 (digest
[1]);
15640 digest
[2] = byte_swap_32 (digest
[2]);
15641 digest
[3] = byte_swap_32 (digest
[3]);
15642 digest
[4] = byte_swap_32 (digest
[4]);
15643 digest
[5] = byte_swap_32 (digest
[5]);
15644 digest
[6] = byte_swap_32 (digest
[6]);
15645 digest
[7] = byte_swap_32 (digest
[7]);
15647 return (PARSER_OK
);
15650 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15652 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15654 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15656 u32
*digest
= (u32
*) hash_buf
->digest
;
15658 salt_t
*salt
= hash_buf
->salt
;
15664 // first is *raw* salt
15666 char *salt_pos
= input_buf
+ 3;
15668 char *hash_pos
= strchr (salt_pos
, '$');
15670 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15672 uint salt_len
= hash_pos
- salt_pos
;
15674 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15676 salt
->salt_len
= salt_len
;
15679 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15681 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15682 salt_buf_ptr
[salt_len
] = 0;
15684 // base64 decode hash
15686 u8 tmp_buf
[100] = { 0 };
15688 uint hash_len
= input_len
- 3 - salt_len
- 1;
15690 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15692 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15694 memcpy (digest
, tmp_buf
, 32);
15697 salt
->scrypt_N
= 16384;
15698 salt
->scrypt_r
= 1;
15699 salt
->scrypt_p
= 1;
15700 salt
->salt_iter
= 1;
15702 return (PARSER_OK
);
15705 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15707 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15709 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15711 u32
*digest
= (u32
*) hash_buf
->digest
;
15713 salt_t
*salt
= hash_buf
->salt
;
15715 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15721 char *version_pos
= input_buf
+ 8 + 1;
15723 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15725 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15727 u32 version_len
= verifierHashSize_pos
- version_pos
;
15729 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15731 verifierHashSize_pos
++;
15733 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15735 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15737 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15739 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15743 char *saltSize_pos
= strchr (keySize_pos
, '*');
15745 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15747 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15749 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15753 char *osalt_pos
= strchr (saltSize_pos
, '*');
15755 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15757 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15759 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15763 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15765 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15769 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15771 encryptedVerifier_pos
++;
15773 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15775 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15777 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15779 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15781 encryptedVerifierHash_pos
++;
15783 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;
15785 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15787 const uint version
= atoi (version_pos
);
15789 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15791 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15793 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15795 const uint keySize
= atoi (keySize_pos
);
15797 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15799 office2007
->keySize
= keySize
;
15801 const uint saltSize
= atoi (saltSize_pos
);
15803 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15809 salt
->salt_len
= 16;
15810 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15812 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15813 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15814 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15815 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15821 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15822 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15823 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15824 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15826 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15827 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15828 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15829 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15830 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15836 digest
[0] = office2007
->encryptedVerifierHash
[0];
15837 digest
[1] = office2007
->encryptedVerifierHash
[1];
15838 digest
[2] = office2007
->encryptedVerifierHash
[2];
15839 digest
[3] = office2007
->encryptedVerifierHash
[3];
15841 return (PARSER_OK
);
15844 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15846 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15848 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15850 u32
*digest
= (u32
*) hash_buf
->digest
;
15852 salt_t
*salt
= hash_buf
->salt
;
15854 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15860 char *version_pos
= input_buf
+ 8 + 1;
15862 char *spinCount_pos
= strchr (version_pos
, '*');
15864 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15866 u32 version_len
= spinCount_pos
- version_pos
;
15868 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15872 char *keySize_pos
= strchr (spinCount_pos
, '*');
15874 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15876 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15878 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15882 char *saltSize_pos
= strchr (keySize_pos
, '*');
15884 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15886 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15888 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15892 char *osalt_pos
= strchr (saltSize_pos
, '*');
15894 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15896 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15898 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15902 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15904 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15906 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15908 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15910 encryptedVerifier_pos
++;
15912 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15914 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15916 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15918 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15920 encryptedVerifierHash_pos
++;
15922 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;
15924 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15926 const uint version
= atoi (version_pos
);
15928 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15930 const uint spinCount
= atoi (spinCount_pos
);
15932 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15934 const uint keySize
= atoi (keySize_pos
);
15936 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15938 const uint saltSize
= atoi (saltSize_pos
);
15940 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15946 salt
->salt_len
= 16;
15947 salt
->salt_iter
= spinCount
;
15949 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15950 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15951 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15952 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15958 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15959 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15960 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15961 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15963 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15964 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15965 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15966 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15967 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15968 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15969 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15970 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15976 digest
[0] = office2010
->encryptedVerifierHash
[0];
15977 digest
[1] = office2010
->encryptedVerifierHash
[1];
15978 digest
[2] = office2010
->encryptedVerifierHash
[2];
15979 digest
[3] = office2010
->encryptedVerifierHash
[3];
15981 return (PARSER_OK
);
15984 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15986 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15988 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15990 u32
*digest
= (u32
*) hash_buf
->digest
;
15992 salt_t
*salt
= hash_buf
->salt
;
15994 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
16000 char *version_pos
= input_buf
+ 8 + 1;
16002 char *spinCount_pos
= strchr (version_pos
, '*');
16004 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16006 u32 version_len
= spinCount_pos
- version_pos
;
16008 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
16012 char *keySize_pos
= strchr (spinCount_pos
, '*');
16014 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16016 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
16018 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
16022 char *saltSize_pos
= strchr (keySize_pos
, '*');
16024 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16026 u32 keySize_len
= saltSize_pos
- keySize_pos
;
16028 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
16032 char *osalt_pos
= strchr (saltSize_pos
, '*');
16034 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16036 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
16038 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
16042 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16044 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16046 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16048 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16050 encryptedVerifier_pos
++;
16052 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16054 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16056 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16058 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16060 encryptedVerifierHash_pos
++;
16062 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;
16064 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
16066 const uint version
= atoi (version_pos
);
16068 if (version
!= 2013) return (PARSER_SALT_VALUE
);
16070 const uint spinCount
= atoi (spinCount_pos
);
16072 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
16074 const uint keySize
= atoi (keySize_pos
);
16076 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
16078 const uint saltSize
= atoi (saltSize_pos
);
16080 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
16086 salt
->salt_len
= 16;
16087 salt
->salt_iter
= spinCount
;
16089 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16090 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16091 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16092 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16098 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16099 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16100 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16101 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16103 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16104 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16105 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16106 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16107 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16108 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
16109 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
16110 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
16116 digest
[0] = office2013
->encryptedVerifierHash
[0];
16117 digest
[1] = office2013
->encryptedVerifierHash
[1];
16118 digest
[2] = office2013
->encryptedVerifierHash
[2];
16119 digest
[3] = office2013
->encryptedVerifierHash
[3];
16121 return (PARSER_OK
);
16124 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16126 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
16128 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16130 u32
*digest
= (u32
*) hash_buf
->digest
;
16132 salt_t
*salt
= hash_buf
->salt
;
16134 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16140 char *version_pos
= input_buf
+ 11;
16142 char *osalt_pos
= strchr (version_pos
, '*');
16144 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16146 u32 version_len
= osalt_pos
- version_pos
;
16148 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16152 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16154 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16156 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16158 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16160 encryptedVerifier_pos
++;
16162 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16164 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16166 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16168 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16170 encryptedVerifierHash_pos
++;
16172 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16174 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16176 const uint version
= *version_pos
- 0x30;
16178 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16184 oldoffice01
->version
= version
;
16186 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16187 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16188 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16189 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16191 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16192 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16193 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16194 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16196 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16197 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16198 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16199 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16201 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16202 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16203 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16204 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16210 salt
->salt_len
= 16;
16212 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16213 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16214 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16215 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16217 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16218 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16219 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16220 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16222 // this is a workaround as office produces multiple documents with the same salt
16224 salt
->salt_len
+= 32;
16226 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16227 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16228 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16229 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16230 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16231 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16232 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16233 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16239 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16240 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16241 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16242 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16244 return (PARSER_OK
);
16247 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16249 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16252 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16254 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16256 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16258 u32
*digest
= (u32
*) hash_buf
->digest
;
16260 salt_t
*salt
= hash_buf
->salt
;
16262 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16268 char *version_pos
= input_buf
+ 11;
16270 char *osalt_pos
= strchr (version_pos
, '*');
16272 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16274 u32 version_len
= osalt_pos
- version_pos
;
16276 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16280 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16282 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16284 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16286 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16288 encryptedVerifier_pos
++;
16290 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16292 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16294 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16296 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16298 encryptedVerifierHash_pos
++;
16300 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16302 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16304 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16306 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16310 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16312 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16314 const uint version
= *version_pos
- 0x30;
16316 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16322 oldoffice01
->version
= version
;
16324 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16325 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16326 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16327 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16329 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16330 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16331 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16332 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16334 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16335 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16336 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16337 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16339 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16340 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16341 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16342 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16344 oldoffice01
->rc4key
[1] = 0;
16345 oldoffice01
->rc4key
[0] = 0;
16347 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16348 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16349 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16350 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16351 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16352 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16353 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16354 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16355 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16356 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16358 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16359 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16365 salt
->salt_len
= 16;
16367 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16368 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16369 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16370 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16372 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16373 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16374 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16375 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16377 // this is a workaround as office produces multiple documents with the same salt
16379 salt
->salt_len
+= 32;
16381 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16382 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16383 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16384 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16385 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16386 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16387 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16388 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16394 digest
[0] = oldoffice01
->rc4key
[0];
16395 digest
[1] = oldoffice01
->rc4key
[1];
16399 return (PARSER_OK
);
16402 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16404 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16406 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16408 u32
*digest
= (u32
*) hash_buf
->digest
;
16410 salt_t
*salt
= hash_buf
->salt
;
16412 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16418 char *version_pos
= input_buf
+ 11;
16420 char *osalt_pos
= strchr (version_pos
, '*');
16422 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16424 u32 version_len
= osalt_pos
- version_pos
;
16426 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16430 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16432 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16434 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16436 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16438 encryptedVerifier_pos
++;
16440 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16442 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16444 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16446 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16448 encryptedVerifierHash_pos
++;
16450 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16452 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16454 const uint version
= *version_pos
- 0x30;
16456 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16462 oldoffice34
->version
= version
;
16464 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16465 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16466 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16467 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16469 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16470 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16471 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16472 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16474 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16475 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16476 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16477 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16478 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16480 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16481 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16482 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16483 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16484 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16490 salt
->salt_len
= 16;
16492 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16493 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16494 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16495 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16497 // this is a workaround as office produces multiple documents with the same salt
16499 salt
->salt_len
+= 32;
16501 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16502 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16503 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16504 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16505 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16506 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16507 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16508 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16514 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16515 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16516 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16517 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16519 return (PARSER_OK
);
16522 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16524 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16526 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16529 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16531 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16533 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16535 u32
*digest
= (u32
*) hash_buf
->digest
;
16537 salt_t
*salt
= hash_buf
->salt
;
16539 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16545 char *version_pos
= input_buf
+ 11;
16547 char *osalt_pos
= strchr (version_pos
, '*');
16549 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 u32 version_len
= osalt_pos
- version_pos
;
16553 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16557 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16559 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16561 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16563 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16565 encryptedVerifier_pos
++;
16567 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16569 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16571 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16573 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16575 encryptedVerifierHash_pos
++;
16577 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16579 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16581 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16583 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16587 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16589 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16591 const uint version
= *version_pos
- 0x30;
16593 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16599 oldoffice34
->version
= version
;
16601 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16602 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16603 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16604 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16606 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16607 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16608 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16609 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16611 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16612 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16613 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16614 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16615 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16617 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16618 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16619 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16620 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16621 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16623 oldoffice34
->rc4key
[1] = 0;
16624 oldoffice34
->rc4key
[0] = 0;
16626 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16627 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16628 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16629 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16630 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16631 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16632 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16633 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16634 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16635 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16637 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16638 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16644 salt
->salt_len
= 16;
16646 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16647 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16648 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16649 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16651 // this is a workaround as office produces multiple documents with the same salt
16653 salt
->salt_len
+= 32;
16655 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16656 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16657 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16658 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16659 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16660 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16661 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16662 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16668 digest
[0] = oldoffice34
->rc4key
[0];
16669 digest
[1] = oldoffice34
->rc4key
[1];
16673 return (PARSER_OK
);
16676 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16678 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16680 u32
*digest
= (u32
*) hash_buf
->digest
;
16682 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16683 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16684 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16685 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16687 digest
[0] = byte_swap_32 (digest
[0]);
16688 digest
[1] = byte_swap_32 (digest
[1]);
16689 digest
[2] = byte_swap_32 (digest
[2]);
16690 digest
[3] = byte_swap_32 (digest
[3]);
16692 return (PARSER_OK
);
16695 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16697 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16699 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16701 u32
*digest
= (u32
*) hash_buf
->digest
;
16703 salt_t
*salt
= hash_buf
->salt
;
16705 char *signature_pos
= input_buf
;
16707 char *salt_pos
= strchr (signature_pos
, '$');
16709 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16711 u32 signature_len
= salt_pos
- signature_pos
;
16713 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16717 char *hash_pos
= strchr (salt_pos
, '$');
16719 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16721 u32 salt_len
= hash_pos
- salt_pos
;
16723 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16727 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16729 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16731 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16732 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16733 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16734 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16735 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16737 digest
[0] -= SHA1M_A
;
16738 digest
[1] -= SHA1M_B
;
16739 digest
[2] -= SHA1M_C
;
16740 digest
[3] -= SHA1M_D
;
16741 digest
[4] -= SHA1M_E
;
16743 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16745 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16747 salt
->salt_len
= salt_len
;
16749 return (PARSER_OK
);
16752 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16754 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16756 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16758 u32
*digest
= (u32
*) hash_buf
->digest
;
16760 salt_t
*salt
= hash_buf
->salt
;
16762 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16768 char *iter_pos
= input_buf
+ 14;
16770 const int iter
= atoi (iter_pos
);
16772 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16774 salt
->salt_iter
= iter
- 1;
16776 char *salt_pos
= strchr (iter_pos
, '$');
16778 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16782 char *hash_pos
= strchr (salt_pos
, '$');
16784 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16786 const uint salt_len
= hash_pos
- salt_pos
;
16790 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16792 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16794 salt
->salt_len
= salt_len
;
16796 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16797 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16799 // add some stuff to normal salt to make sorted happy
16801 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16802 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16803 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16804 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16805 salt
->salt_buf
[4] = salt
->salt_iter
;
16807 // base64 decode hash
16809 u8 tmp_buf
[100] = { 0 };
16811 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16813 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16815 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16817 memcpy (digest
, tmp_buf
, 32);
16819 digest
[0] = byte_swap_32 (digest
[0]);
16820 digest
[1] = byte_swap_32 (digest
[1]);
16821 digest
[2] = byte_swap_32 (digest
[2]);
16822 digest
[3] = byte_swap_32 (digest
[3]);
16823 digest
[4] = byte_swap_32 (digest
[4]);
16824 digest
[5] = byte_swap_32 (digest
[5]);
16825 digest
[6] = byte_swap_32 (digest
[6]);
16826 digest
[7] = byte_swap_32 (digest
[7]);
16828 return (PARSER_OK
);
16831 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16833 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16835 u32
*digest
= (u32
*) hash_buf
->digest
;
16837 salt_t
*salt
= hash_buf
->salt
;
16839 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16840 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16844 digest
[0] = byte_swap_32 (digest
[0]);
16845 digest
[1] = byte_swap_32 (digest
[1]);
16847 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16848 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16849 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16851 char iter_c
= input_buf
[17];
16852 char iter_d
= input_buf
[19];
16854 // atm only defaults, let's see if there's more request
16855 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16856 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16858 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16860 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16861 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16862 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16863 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16865 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16866 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16867 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16868 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16870 salt
->salt_len
= 16;
16872 return (PARSER_OK
);
16875 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16877 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16879 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16881 u32
*digest
= (u32
*) hash_buf
->digest
;
16883 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16885 salt_t
*salt
= hash_buf
->salt
;
16887 char *salt_pos
= input_buf
+ 10;
16889 char *hash_pos
= strchr (salt_pos
, '$');
16891 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16893 uint salt_len
= hash_pos
- salt_pos
;
16897 uint hash_len
= input_len
- 10 - salt_len
- 1;
16899 // base64 decode salt
16901 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16903 u8 tmp_buf
[100] = { 0 };
16905 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16907 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16909 tmp_buf
[salt_len
] = 0x80;
16911 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16913 salt
->salt_len
= salt_len
;
16915 // base64 decode hash
16917 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16919 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16921 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16923 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16925 uint user_len
= hash_len
- 32;
16927 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16929 user_len
--; // skip the trailing space
16931 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16932 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16933 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16934 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16936 digest
[0] = byte_swap_32 (digest
[0]);
16937 digest
[1] = byte_swap_32 (digest
[1]);
16938 digest
[2] = byte_swap_32 (digest
[2]);
16939 digest
[3] = byte_swap_32 (digest
[3]);
16941 // store username for host only (output hash if cracked)
16943 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16944 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16946 return (PARSER_OK
);
16949 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16951 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16953 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16955 u32
*digest
= (u32
*) hash_buf
->digest
;
16957 salt_t
*salt
= hash_buf
->salt
;
16959 char *iter_pos
= input_buf
+ 10;
16961 u32 iter
= atoi (iter_pos
);
16965 return (PARSER_SALT_ITERATION
);
16968 iter
--; // first iteration is special
16970 salt
->salt_iter
= iter
;
16972 char *base64_pos
= strchr (iter_pos
, '}');
16974 if (base64_pos
== NULL
)
16976 return (PARSER_SIGNATURE_UNMATCHED
);
16981 // base64 decode salt
16983 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16985 u8 tmp_buf
[100] = { 0 };
16987 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16989 if (decoded_len
< 24)
16991 return (PARSER_SALT_LENGTH
);
16996 uint salt_len
= decoded_len
- 20;
16998 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16999 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
17001 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
17003 salt
->salt_len
= salt_len
;
17007 u32
*digest_ptr
= (u32
*) tmp_buf
;
17009 digest
[0] = byte_swap_32 (digest_ptr
[0]);
17010 digest
[1] = byte_swap_32 (digest_ptr
[1]);
17011 digest
[2] = byte_swap_32 (digest_ptr
[2]);
17012 digest
[3] = byte_swap_32 (digest_ptr
[3]);
17013 digest
[4] = byte_swap_32 (digest_ptr
[4]);
17015 return (PARSER_OK
);
17018 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17020 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
17022 u32
*digest
= (u32
*) hash_buf
->digest
;
17024 salt_t
*salt
= hash_buf
->salt
;
17026 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17027 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17028 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17029 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17030 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
17032 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17034 uint salt_len
= input_len
- 40 - 1;
17036 char *salt_buf
= input_buf
+ 40 + 1;
17038 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17040 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17042 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
17044 salt
->salt_len
= salt_len
;
17046 return (PARSER_OK
);
17049 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17051 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
17053 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17055 u32
*digest
= (u32
*) hash_buf
->digest
;
17057 salt_t
*salt
= hash_buf
->salt
;
17059 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17065 char *V_pos
= input_buf
+ 5;
17067 char *R_pos
= strchr (V_pos
, '*');
17069 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17071 u32 V_len
= R_pos
- V_pos
;
17075 char *bits_pos
= strchr (R_pos
, '*');
17077 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17079 u32 R_len
= bits_pos
- R_pos
;
17083 char *P_pos
= strchr (bits_pos
, '*');
17085 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17087 u32 bits_len
= P_pos
- bits_pos
;
17091 char *enc_md_pos
= strchr (P_pos
, '*');
17093 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17095 u32 P_len
= enc_md_pos
- P_pos
;
17099 char *id_len_pos
= strchr (enc_md_pos
, '*');
17101 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17103 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17107 char *id_buf_pos
= strchr (id_len_pos
, '*');
17109 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17111 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17115 char *u_len_pos
= strchr (id_buf_pos
, '*');
17117 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17119 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17121 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17125 char *u_buf_pos
= strchr (u_len_pos
, '*');
17127 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17129 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17133 char *o_len_pos
= strchr (u_buf_pos
, '*');
17135 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17137 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17139 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17143 char *o_buf_pos
= strchr (o_len_pos
, '*');
17145 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17147 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17151 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;
17153 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17157 const int V
= atoi (V_pos
);
17158 const int R
= atoi (R_pos
);
17159 const int P
= atoi (P_pos
);
17161 if (V
!= 1) return (PARSER_SALT_VALUE
);
17162 if (R
!= 2) return (PARSER_SALT_VALUE
);
17164 const int enc_md
= atoi (enc_md_pos
);
17166 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17168 const int id_len
= atoi (id_len_pos
);
17169 const int u_len
= atoi (u_len_pos
);
17170 const int o_len
= atoi (o_len_pos
);
17172 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17173 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17174 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17176 const int bits
= atoi (bits_pos
);
17178 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17180 // copy data to esalt
17186 pdf
->enc_md
= enc_md
;
17188 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17189 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17190 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17191 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17192 pdf
->id_len
= id_len
;
17194 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17195 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17196 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17197 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17198 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17199 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17200 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17201 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17202 pdf
->u_len
= u_len
;
17204 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17205 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17206 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17207 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17208 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17209 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17210 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17211 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17212 pdf
->o_len
= o_len
;
17214 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17215 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17216 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17217 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17219 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17220 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17221 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17222 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17223 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17224 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17225 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17226 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17228 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17229 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17230 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17231 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17232 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17233 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17234 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17235 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17237 // we use ID for salt, maybe needs to change, we will see...
17239 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17240 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17241 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17242 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17243 salt
->salt_len
= pdf
->id_len
;
17245 digest
[0] = pdf
->u_buf
[0];
17246 digest
[1] = pdf
->u_buf
[1];
17247 digest
[2] = pdf
->u_buf
[2];
17248 digest
[3] = pdf
->u_buf
[3];
17250 return (PARSER_OK
);
17253 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17255 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17258 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17260 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17262 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17264 u32
*digest
= (u32
*) hash_buf
->digest
;
17266 salt_t
*salt
= hash_buf
->salt
;
17268 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17274 char *V_pos
= input_buf
+ 5;
17276 char *R_pos
= strchr (V_pos
, '*');
17278 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17280 u32 V_len
= R_pos
- V_pos
;
17284 char *bits_pos
= strchr (R_pos
, '*');
17286 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17288 u32 R_len
= bits_pos
- R_pos
;
17292 char *P_pos
= strchr (bits_pos
, '*');
17294 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17296 u32 bits_len
= P_pos
- bits_pos
;
17300 char *enc_md_pos
= strchr (P_pos
, '*');
17302 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 u32 P_len
= enc_md_pos
- P_pos
;
17308 char *id_len_pos
= strchr (enc_md_pos
, '*');
17310 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17312 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17316 char *id_buf_pos
= strchr (id_len_pos
, '*');
17318 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17324 char *u_len_pos
= strchr (id_buf_pos
, '*');
17326 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17330 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17334 char *u_buf_pos
= strchr (u_len_pos
, '*');
17336 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17338 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17342 char *o_len_pos
= strchr (u_buf_pos
, '*');
17344 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17346 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17348 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17352 char *o_buf_pos
= strchr (o_len_pos
, '*');
17354 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17360 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17362 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17364 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17366 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17370 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;
17372 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17376 const int V
= atoi (V_pos
);
17377 const int R
= atoi (R_pos
);
17378 const int P
= atoi (P_pos
);
17380 if (V
!= 1) return (PARSER_SALT_VALUE
);
17381 if (R
!= 2) return (PARSER_SALT_VALUE
);
17383 const int enc_md
= atoi (enc_md_pos
);
17385 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17387 const int id_len
= atoi (id_len_pos
);
17388 const int u_len
= atoi (u_len_pos
);
17389 const int o_len
= atoi (o_len_pos
);
17391 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17392 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17393 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17395 const int bits
= atoi (bits_pos
);
17397 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17399 // copy data to esalt
17405 pdf
->enc_md
= enc_md
;
17407 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17408 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17409 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17410 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17411 pdf
->id_len
= id_len
;
17413 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17414 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17415 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17416 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17417 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17418 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17419 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17420 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17421 pdf
->u_len
= u_len
;
17423 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17424 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17425 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17426 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17427 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17428 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17429 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17430 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17431 pdf
->o_len
= o_len
;
17433 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17434 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17435 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17436 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17438 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17439 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17440 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17441 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17442 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17443 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17444 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17445 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17447 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17448 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17449 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17450 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17451 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17452 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17453 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17454 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17456 pdf
->rc4key
[1] = 0;
17457 pdf
->rc4key
[0] = 0;
17459 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17460 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17461 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17462 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17463 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17464 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17465 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17466 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17467 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17468 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17470 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17471 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17473 // we use ID for salt, maybe needs to change, we will see...
17475 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17476 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17477 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17478 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17479 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17480 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17481 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17482 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17483 salt
->salt_len
= pdf
->id_len
+ 16;
17485 digest
[0] = pdf
->rc4key
[0];
17486 digest
[1] = pdf
->rc4key
[1];
17490 return (PARSER_OK
);
17493 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17495 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17497 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17499 u32
*digest
= (u32
*) hash_buf
->digest
;
17501 salt_t
*salt
= hash_buf
->salt
;
17503 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17509 char *V_pos
= input_buf
+ 5;
17511 char *R_pos
= strchr (V_pos
, '*');
17513 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17515 u32 V_len
= R_pos
- V_pos
;
17519 char *bits_pos
= strchr (R_pos
, '*');
17521 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17523 u32 R_len
= bits_pos
- R_pos
;
17527 char *P_pos
= strchr (bits_pos
, '*');
17529 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17531 u32 bits_len
= P_pos
- bits_pos
;
17535 char *enc_md_pos
= strchr (P_pos
, '*');
17537 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17539 u32 P_len
= enc_md_pos
- P_pos
;
17543 char *id_len_pos
= strchr (enc_md_pos
, '*');
17545 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17547 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17551 char *id_buf_pos
= strchr (id_len_pos
, '*');
17553 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17555 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17559 char *u_len_pos
= strchr (id_buf_pos
, '*');
17561 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17563 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17565 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17569 char *u_buf_pos
= strchr (u_len_pos
, '*');
17571 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17573 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17577 char *o_len_pos
= strchr (u_buf_pos
, '*');
17579 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17583 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17587 char *o_buf_pos
= strchr (o_len_pos
, '*');
17589 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17591 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17595 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;
17597 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17601 const int V
= atoi (V_pos
);
17602 const int R
= atoi (R_pos
);
17603 const int P
= atoi (P_pos
);
17607 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17608 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17610 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17612 const int id_len
= atoi (id_len_pos
);
17613 const int u_len
= atoi (u_len_pos
);
17614 const int o_len
= atoi (o_len_pos
);
17616 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17618 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17619 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17621 const int bits
= atoi (bits_pos
);
17623 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17629 enc_md
= atoi (enc_md_pos
);
17632 // copy data to esalt
17638 pdf
->enc_md
= enc_md
;
17640 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17641 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17642 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17643 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17647 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17648 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17649 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17650 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17653 pdf
->id_len
= id_len
;
17655 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17656 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17657 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17658 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17659 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17660 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17661 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17662 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17663 pdf
->u_len
= u_len
;
17665 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17666 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17667 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17668 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17669 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17670 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17671 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17672 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17673 pdf
->o_len
= o_len
;
17675 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17676 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17677 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17678 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17682 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17683 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17684 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17685 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17688 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17689 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17690 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17691 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17692 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17693 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17694 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17695 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17697 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17698 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17699 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17700 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17701 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17702 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17703 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17704 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17706 // precompute rc4 data for later use
17722 uint salt_pc_block
[32] = { 0 };
17724 char *salt_pc_ptr
= (char *) salt_pc_block
;
17726 memcpy (salt_pc_ptr
, padding
, 32);
17727 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17729 uint salt_pc_digest
[4] = { 0 };
17731 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17733 pdf
->rc4data
[0] = salt_pc_digest
[0];
17734 pdf
->rc4data
[1] = salt_pc_digest
[1];
17736 // we use ID for salt, maybe needs to change, we will see...
17738 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17739 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17740 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17741 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17742 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17743 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17744 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17745 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17746 salt
->salt_len
= pdf
->id_len
+ 16;
17748 salt
->salt_iter
= ROUNDS_PDF14
;
17750 digest
[0] = pdf
->u_buf
[0];
17751 digest
[1] = pdf
->u_buf
[1];
17755 return (PARSER_OK
);
17758 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17760 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17762 if (ret
!= PARSER_OK
)
17767 u32
*digest
= (u32
*) hash_buf
->digest
;
17769 salt_t
*salt
= hash_buf
->salt
;
17771 digest
[0] -= SHA256M_A
;
17772 digest
[1] -= SHA256M_B
;
17773 digest
[2] -= SHA256M_C
;
17774 digest
[3] -= SHA256M_D
;
17775 digest
[4] -= SHA256M_E
;
17776 digest
[5] -= SHA256M_F
;
17777 digest
[6] -= SHA256M_G
;
17778 digest
[7] -= SHA256M_H
;
17780 salt
->salt_buf
[2] = 0x80;
17782 return (PARSER_OK
);
17785 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17787 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17789 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17791 u32
*digest
= (u32
*) hash_buf
->digest
;
17793 salt_t
*salt
= hash_buf
->salt
;
17795 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17801 char *V_pos
= input_buf
+ 5;
17803 char *R_pos
= strchr (V_pos
, '*');
17805 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17807 u32 V_len
= R_pos
- V_pos
;
17811 char *bits_pos
= strchr (R_pos
, '*');
17813 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17815 u32 R_len
= bits_pos
- R_pos
;
17819 char *P_pos
= strchr (bits_pos
, '*');
17821 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17823 u32 bits_len
= P_pos
- bits_pos
;
17827 char *enc_md_pos
= strchr (P_pos
, '*');
17829 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17831 u32 P_len
= enc_md_pos
- P_pos
;
17835 char *id_len_pos
= strchr (enc_md_pos
, '*');
17837 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17839 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17843 char *id_buf_pos
= strchr (id_len_pos
, '*');
17845 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17847 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17851 char *u_len_pos
= strchr (id_buf_pos
, '*');
17853 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17855 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17859 char *u_buf_pos
= strchr (u_len_pos
, '*');
17861 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17863 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17867 char *o_len_pos
= strchr (u_buf_pos
, '*');
17869 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17871 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17875 char *o_buf_pos
= strchr (o_len_pos
, '*');
17877 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17879 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17883 char *last
= strchr (o_buf_pos
, '*');
17885 if (last
== NULL
) last
= input_buf
+ input_len
;
17887 u32 o_buf_len
= last
- o_buf_pos
;
17891 const int V
= atoi (V_pos
);
17892 const int R
= atoi (R_pos
);
17896 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17897 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17899 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17901 const int bits
= atoi (bits_pos
);
17903 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17905 int enc_md
= atoi (enc_md_pos
);
17907 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17909 const uint id_len
= atoi (id_len_pos
);
17910 const uint u_len
= atoi (u_len_pos
);
17911 const uint o_len
= atoi (o_len_pos
);
17913 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17914 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17915 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17916 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17917 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17918 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17919 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17920 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17922 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17923 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17924 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17926 // copy data to esalt
17928 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17930 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17932 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17935 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17936 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17938 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17939 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17941 salt
->salt_len
= 8;
17942 salt
->salt_iter
= ROUNDS_PDF17L8
;
17944 digest
[0] = pdf
->u_buf
[0];
17945 digest
[1] = pdf
->u_buf
[1];
17946 digest
[2] = pdf
->u_buf
[2];
17947 digest
[3] = pdf
->u_buf
[3];
17948 digest
[4] = pdf
->u_buf
[4];
17949 digest
[5] = pdf
->u_buf
[5];
17950 digest
[6] = pdf
->u_buf
[6];
17951 digest
[7] = pdf
->u_buf
[7];
17953 return (PARSER_OK
);
17956 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17958 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17960 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17962 u32
*digest
= (u32
*) hash_buf
->digest
;
17964 salt_t
*salt
= hash_buf
->salt
;
17966 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17974 char *iter_pos
= input_buf
+ 7;
17976 u32 iter
= atoi (iter_pos
);
17978 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17979 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17981 // first is *raw* salt
17983 char *salt_pos
= strchr (iter_pos
, ':');
17985 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17989 char *hash_pos
= strchr (salt_pos
, ':');
17991 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17993 u32 salt_len
= hash_pos
- salt_pos
;
17995 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17999 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18001 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18005 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
18007 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18009 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18011 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18012 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18014 salt
->salt_len
= salt_len
;
18015 salt
->salt_iter
= iter
- 1;
18019 u8 tmp_buf
[100] = { 0 };
18021 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18023 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18025 memcpy (digest
, tmp_buf
, 16);
18027 digest
[0] = byte_swap_32 (digest
[0]);
18028 digest
[1] = byte_swap_32 (digest
[1]);
18029 digest
[2] = byte_swap_32 (digest
[2]);
18030 digest
[3] = byte_swap_32 (digest
[3]);
18032 // add some stuff to normal salt to make sorted happy
18034 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
18035 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
18036 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
18037 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
18038 salt
->salt_buf
[4] = salt
->salt_iter
;
18040 return (PARSER_OK
);
18043 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18045 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
18047 u32
*digest
= (u32
*) hash_buf
->digest
;
18049 salt_t
*salt
= hash_buf
->salt
;
18051 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18052 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18053 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18054 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18056 digest
[0] = byte_swap_32 (digest
[0]);
18057 digest
[1] = byte_swap_32 (digest
[1]);
18058 digest
[2] = byte_swap_32 (digest
[2]);
18059 digest
[3] = byte_swap_32 (digest
[3]);
18061 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18063 uint salt_len
= input_len
- 32 - 1;
18065 char *salt_buf
= input_buf
+ 32 + 1;
18067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18071 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18073 salt
->salt_len
= salt_len
;
18075 return (PARSER_OK
);
18078 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18080 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
18082 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18084 u32
*digest
= (u32
*) hash_buf
->digest
;
18086 salt_t
*salt
= hash_buf
->salt
;
18088 char *user_pos
= input_buf
+ 10;
18090 char *salt_pos
= strchr (user_pos
, '*');
18092 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18096 char *hash_pos
= strchr (salt_pos
, '*');
18100 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18102 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
18104 uint user_len
= salt_pos
- user_pos
- 1;
18106 uint salt_len
= hash_pos
- salt_pos
- 1;
18108 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
18114 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18115 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18116 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18117 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18119 digest
[0] = byte_swap_32 (digest
[0]);
18120 digest
[1] = byte_swap_32 (digest
[1]);
18121 digest
[2] = byte_swap_32 (digest
[2]);
18122 digest
[3] = byte_swap_32 (digest
[3]);
18124 digest
[0] -= MD5M_A
;
18125 digest
[1] -= MD5M_B
;
18126 digest
[2] -= MD5M_C
;
18127 digest
[3] -= MD5M_D
;
18133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18135 // first 4 bytes are the "challenge"
18137 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18138 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18139 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18140 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18142 // append the user name
18144 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18146 salt
->salt_len
= 4 + user_len
;
18148 return (PARSER_OK
);
18151 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18153 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18155 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18157 u32
*digest
= (u32
*) hash_buf
->digest
;
18159 salt_t
*salt
= hash_buf
->salt
;
18161 char *salt_pos
= input_buf
+ 9;
18163 char *hash_pos
= strchr (salt_pos
, '*');
18165 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18169 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18171 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18173 uint salt_len
= hash_pos
- salt_pos
- 1;
18175 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18181 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18182 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18183 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18184 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18185 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18193 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18195 salt
->salt_len
= salt_len
;
18197 return (PARSER_OK
);
18200 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18202 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18204 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18206 u32
*digest
= (u32
*) hash_buf
->digest
;
18208 salt_t
*salt
= hash_buf
->salt
;
18210 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18216 char *cry_master_len_pos
= input_buf
+ 9;
18218 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18220 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18222 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18224 cry_master_buf_pos
++;
18226 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18228 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18230 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18232 cry_salt_len_pos
++;
18234 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18236 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18238 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18240 cry_salt_buf_pos
++;
18242 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18244 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18246 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18250 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18252 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18254 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18258 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18260 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18262 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18266 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18268 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18270 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18272 public_key_len_pos
++;
18274 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18276 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18278 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18280 public_key_buf_pos
++;
18282 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;
18284 const uint cry_master_len
= atoi (cry_master_len_pos
);
18285 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18286 const uint ckey_len
= atoi (ckey_len_pos
);
18287 const uint public_key_len
= atoi (public_key_len_pos
);
18289 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18290 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18291 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18292 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18294 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18296 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18298 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18301 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18303 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18305 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18308 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18310 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18312 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18315 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18316 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18317 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18320 * store digest (should be unique enought, hopefully)
18323 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18324 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18325 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18326 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18332 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18334 const uint cry_rounds
= atoi (cry_rounds_pos
);
18336 salt
->salt_iter
= cry_rounds
- 1;
18338 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18340 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18342 salt
->salt_len
= salt_len
;
18344 return (PARSER_OK
);
18347 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18349 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18351 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18353 u32
*digest
= (u32
*) hash_buf
->digest
;
18355 salt_t
*salt
= hash_buf
->salt
;
18357 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18359 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18361 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18363 memcpy (temp_input_buf
, input_buf
, input_len
);
18367 char *URI_server_pos
= temp_input_buf
+ 6;
18369 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18371 if (URI_client_pos
== NULL
)
18373 myfree (temp_input_buf
);
18375 return (PARSER_SEPARATOR_UNMATCHED
);
18378 URI_client_pos
[0] = 0;
18381 uint URI_server_len
= strlen (URI_server_pos
);
18383 if (URI_server_len
> 512)
18385 myfree (temp_input_buf
);
18387 return (PARSER_SALT_LENGTH
);
18392 char *user_pos
= strchr (URI_client_pos
, '*');
18394 if (user_pos
== NULL
)
18396 myfree (temp_input_buf
);
18398 return (PARSER_SEPARATOR_UNMATCHED
);
18404 uint URI_client_len
= strlen (URI_client_pos
);
18406 if (URI_client_len
> 512)
18408 myfree (temp_input_buf
);
18410 return (PARSER_SALT_LENGTH
);
18415 char *realm_pos
= strchr (user_pos
, '*');
18417 if (realm_pos
== NULL
)
18419 myfree (temp_input_buf
);
18421 return (PARSER_SEPARATOR_UNMATCHED
);
18427 uint user_len
= strlen (user_pos
);
18429 if (user_len
> 116)
18431 myfree (temp_input_buf
);
18433 return (PARSER_SALT_LENGTH
);
18438 char *method_pos
= strchr (realm_pos
, '*');
18440 if (method_pos
== NULL
)
18442 myfree (temp_input_buf
);
18444 return (PARSER_SEPARATOR_UNMATCHED
);
18450 uint realm_len
= strlen (realm_pos
);
18452 if (realm_len
> 116)
18454 myfree (temp_input_buf
);
18456 return (PARSER_SALT_LENGTH
);
18461 char *URI_prefix_pos
= strchr (method_pos
, '*');
18463 if (URI_prefix_pos
== NULL
)
18465 myfree (temp_input_buf
);
18467 return (PARSER_SEPARATOR_UNMATCHED
);
18470 URI_prefix_pos
[0] = 0;
18473 uint method_len
= strlen (method_pos
);
18475 if (method_len
> 246)
18477 myfree (temp_input_buf
);
18479 return (PARSER_SALT_LENGTH
);
18484 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18486 if (URI_resource_pos
== NULL
)
18488 myfree (temp_input_buf
);
18490 return (PARSER_SEPARATOR_UNMATCHED
);
18493 URI_resource_pos
[0] = 0;
18494 URI_resource_pos
++;
18496 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18498 if (URI_prefix_len
> 245)
18500 myfree (temp_input_buf
);
18502 return (PARSER_SALT_LENGTH
);
18507 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18509 if (URI_suffix_pos
== NULL
)
18511 myfree (temp_input_buf
);
18513 return (PARSER_SEPARATOR_UNMATCHED
);
18516 URI_suffix_pos
[0] = 0;
18519 uint URI_resource_len
= strlen (URI_resource_pos
);
18521 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18523 myfree (temp_input_buf
);
18525 return (PARSER_SALT_LENGTH
);
18530 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18532 if (nonce_pos
== NULL
)
18534 myfree (temp_input_buf
);
18536 return (PARSER_SEPARATOR_UNMATCHED
);
18542 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18544 if (URI_suffix_len
> 245)
18546 myfree (temp_input_buf
);
18548 return (PARSER_SALT_LENGTH
);
18553 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18555 if (nonce_client_pos
== NULL
)
18557 myfree (temp_input_buf
);
18559 return (PARSER_SEPARATOR_UNMATCHED
);
18562 nonce_client_pos
[0] = 0;
18563 nonce_client_pos
++;
18565 uint nonce_len
= strlen (nonce_pos
);
18567 if (nonce_len
< 1 || nonce_len
> 50)
18569 myfree (temp_input_buf
);
18571 return (PARSER_SALT_LENGTH
);
18576 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18578 if (nonce_count_pos
== NULL
)
18580 myfree (temp_input_buf
);
18582 return (PARSER_SEPARATOR_UNMATCHED
);
18585 nonce_count_pos
[0] = 0;
18588 uint nonce_client_len
= strlen (nonce_client_pos
);
18590 if (nonce_client_len
> 50)
18592 myfree (temp_input_buf
);
18594 return (PARSER_SALT_LENGTH
);
18599 char *qop_pos
= strchr (nonce_count_pos
, '*');
18601 if (qop_pos
== NULL
)
18603 myfree (temp_input_buf
);
18605 return (PARSER_SEPARATOR_UNMATCHED
);
18611 uint nonce_count_len
= strlen (nonce_count_pos
);
18613 if (nonce_count_len
> 50)
18615 myfree (temp_input_buf
);
18617 return (PARSER_SALT_LENGTH
);
18622 char *directive_pos
= strchr (qop_pos
, '*');
18624 if (directive_pos
== NULL
)
18626 myfree (temp_input_buf
);
18628 return (PARSER_SEPARATOR_UNMATCHED
);
18631 directive_pos
[0] = 0;
18634 uint qop_len
= strlen (qop_pos
);
18638 myfree (temp_input_buf
);
18640 return (PARSER_SALT_LENGTH
);
18645 char *digest_pos
= strchr (directive_pos
, '*');
18647 if (digest_pos
== NULL
)
18649 myfree (temp_input_buf
);
18651 return (PARSER_SEPARATOR_UNMATCHED
);
18657 uint directive_len
= strlen (directive_pos
);
18659 if (directive_len
!= 3)
18661 myfree (temp_input_buf
);
18663 return (PARSER_SALT_LENGTH
);
18666 if (memcmp (directive_pos
, "MD5", 3))
18668 log_info ("ERROR: Only the MD5 directive is currently supported\n");
18670 myfree (temp_input_buf
);
18672 return (PARSER_SIP_AUTH_DIRECTIVE
);
18676 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18681 uint md5_max_len
= 4 * 64;
18683 uint md5_remaining_len
= md5_max_len
;
18685 uint tmp_md5_buf
[64] = { 0 };
18687 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18689 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18691 md5_len
+= method_len
+ 1;
18692 tmp_md5_ptr
+= method_len
+ 1;
18694 if (URI_prefix_len
> 0)
18696 md5_remaining_len
= md5_max_len
- md5_len
;
18698 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18700 md5_len
+= URI_prefix_len
+ 1;
18701 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18704 md5_remaining_len
= md5_max_len
- md5_len
;
18706 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18708 md5_len
+= URI_resource_len
;
18709 tmp_md5_ptr
+= URI_resource_len
;
18711 if (URI_suffix_len
> 0)
18713 md5_remaining_len
= md5_max_len
- md5_len
;
18715 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18717 md5_len
+= 1 + URI_suffix_len
;
18720 uint tmp_digest
[4] = { 0 };
18722 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18724 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18725 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18726 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18727 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18733 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18735 uint esalt_len
= 0;
18737 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18739 // there are 2 possibilities for the esalt:
18741 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18743 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18745 if (esalt_len
> max_esalt_len
)
18747 myfree (temp_input_buf
);
18749 return (PARSER_SALT_LENGTH
);
18752 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18764 esalt_len
= 1 + nonce_len
+ 1 + 32;
18766 if (esalt_len
> max_esalt_len
)
18768 myfree (temp_input_buf
);
18770 return (PARSER_SALT_LENGTH
);
18773 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18781 // add 0x80 to esalt
18783 esalt_buf_ptr
[esalt_len
] = 0x80;
18785 sip
->esalt_len
= esalt_len
;
18791 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18793 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18795 uint max_salt_len
= 119;
18797 if (salt_len
> max_salt_len
)
18799 myfree (temp_input_buf
);
18801 return (PARSER_SALT_LENGTH
);
18804 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18806 sip
->salt_len
= salt_len
;
18809 * fake salt (for sorting)
18812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18816 uint fake_salt_len
= salt_len
;
18818 if (fake_salt_len
> max_salt_len
)
18820 fake_salt_len
= max_salt_len
;
18823 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18825 salt
->salt_len
= fake_salt_len
;
18831 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18832 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18833 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18834 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18836 digest
[0] = byte_swap_32 (digest
[0]);
18837 digest
[1] = byte_swap_32 (digest
[1]);
18838 digest
[2] = byte_swap_32 (digest
[2]);
18839 digest
[3] = byte_swap_32 (digest
[3]);
18841 myfree (temp_input_buf
);
18843 return (PARSER_OK
);
18846 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18848 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18850 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18852 u32
*digest
= (u32
*) hash_buf
->digest
;
18854 salt_t
*salt
= hash_buf
->salt
;
18858 char *digest_pos
= input_buf
;
18860 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18867 char *salt_buf
= input_buf
+ 8 + 1;
18871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18873 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18875 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18877 salt
->salt_len
= salt_len
;
18879 return (PARSER_OK
);
18882 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18884 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18886 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18888 u32
*digest
= (u32
*) hash_buf
->digest
;
18890 salt_t
*salt
= hash_buf
->salt
;
18892 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18898 char *p_buf_pos
= input_buf
+ 4;
18900 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18902 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18904 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18906 NumCyclesPower_pos
++;
18908 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18910 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18912 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18916 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18918 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18920 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18924 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18926 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18928 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18932 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18934 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18936 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18940 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18942 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18944 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18948 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18950 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18952 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18956 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18958 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18960 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18964 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18966 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18968 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18972 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;
18974 const uint iter
= atoi (NumCyclesPower_pos
);
18975 const uint crc
= atoi (crc_buf_pos
);
18976 const uint p_buf
= atoi (p_buf_pos
);
18977 const uint salt_len
= atoi (salt_len_pos
);
18978 const uint iv_len
= atoi (iv_len_pos
);
18979 const uint unpack_size
= atoi (unpack_size_pos
);
18980 const uint data_len
= atoi (data_len_pos
);
18986 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18987 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18989 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18991 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18993 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18999 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
19000 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
19001 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
19002 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
19004 seven_zip
->iv_len
= iv_len
;
19006 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
19008 seven_zip
->salt_len
= 0;
19010 seven_zip
->crc
= crc
;
19012 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
19014 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
19016 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
19019 seven_zip
->data_len
= data_len
;
19021 seven_zip
->unpack_size
= unpack_size
;
19025 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
19026 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
19027 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
19028 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
19030 salt
->salt_len
= 16;
19032 salt
->salt_sign
[0] = iter
;
19034 salt
->salt_iter
= 1 << iter
;
19045 return (PARSER_OK
);
19048 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19050 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
19052 u32
*digest
= (u32
*) hash_buf
->digest
;
19054 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19055 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19056 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19057 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19058 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19059 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19060 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19061 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19063 digest
[0] = byte_swap_32 (digest
[0]);
19064 digest
[1] = byte_swap_32 (digest
[1]);
19065 digest
[2] = byte_swap_32 (digest
[2]);
19066 digest
[3] = byte_swap_32 (digest
[3]);
19067 digest
[4] = byte_swap_32 (digest
[4]);
19068 digest
[5] = byte_swap_32 (digest
[5]);
19069 digest
[6] = byte_swap_32 (digest
[6]);
19070 digest
[7] = byte_swap_32 (digest
[7]);
19072 return (PARSER_OK
);
19075 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19077 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
19079 u32
*digest
= (u32
*) hash_buf
->digest
;
19081 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19082 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19083 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
19084 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
19085 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
19086 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
19087 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
19088 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
19089 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
19090 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
19091 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
19092 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
19093 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
19094 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
19095 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
19096 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
19098 digest
[ 0] = byte_swap_32 (digest
[ 0]);
19099 digest
[ 1] = byte_swap_32 (digest
[ 1]);
19100 digest
[ 2] = byte_swap_32 (digest
[ 2]);
19101 digest
[ 3] = byte_swap_32 (digest
[ 3]);
19102 digest
[ 4] = byte_swap_32 (digest
[ 4]);
19103 digest
[ 5] = byte_swap_32 (digest
[ 5]);
19104 digest
[ 6] = byte_swap_32 (digest
[ 6]);
19105 digest
[ 7] = byte_swap_32 (digest
[ 7]);
19106 digest
[ 8] = byte_swap_32 (digest
[ 8]);
19107 digest
[ 9] = byte_swap_32 (digest
[ 9]);
19108 digest
[10] = byte_swap_32 (digest
[10]);
19109 digest
[11] = byte_swap_32 (digest
[11]);
19110 digest
[12] = byte_swap_32 (digest
[12]);
19111 digest
[13] = byte_swap_32 (digest
[13]);
19112 digest
[14] = byte_swap_32 (digest
[14]);
19113 digest
[15] = byte_swap_32 (digest
[15]);
19115 return (PARSER_OK
);
19118 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19120 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
19122 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
19124 u32
*digest
= (u32
*) hash_buf
->digest
;
19126 salt_t
*salt
= hash_buf
->salt
;
19128 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19136 char *iter_pos
= input_buf
+ 4;
19138 u32 iter
= atoi (iter_pos
);
19140 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19141 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19143 // first is *raw* salt
19145 char *salt_pos
= strchr (iter_pos
, ':');
19147 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19151 char *hash_pos
= strchr (salt_pos
, ':');
19153 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19155 u32 salt_len
= hash_pos
- salt_pos
;
19157 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19161 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19163 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19167 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19173 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19174 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19176 salt
->salt_len
= salt_len
;
19177 salt
->salt_iter
= iter
- 1;
19181 u8 tmp_buf
[100] = { 0 };
19183 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19185 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19187 memcpy (digest
, tmp_buf
, 16);
19189 // add some stuff to normal salt to make sorted happy
19191 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19192 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19193 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19194 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19195 salt
->salt_buf
[4] = salt
->salt_iter
;
19197 return (PARSER_OK
);
19200 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19202 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19204 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19206 u32
*digest
= (u32
*) hash_buf
->digest
;
19208 salt_t
*salt
= hash_buf
->salt
;
19210 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19218 char *iter_pos
= input_buf
+ 5;
19220 u32 iter
= atoi (iter_pos
);
19222 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19223 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19225 // first is *raw* salt
19227 char *salt_pos
= strchr (iter_pos
, ':');
19229 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19233 char *hash_pos
= strchr (salt_pos
, ':');
19235 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19237 u32 salt_len
= hash_pos
- salt_pos
;
19239 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19243 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19245 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19249 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19251 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19253 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19255 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19256 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19258 salt
->salt_len
= salt_len
;
19259 salt
->salt_iter
= iter
- 1;
19263 u8 tmp_buf
[100] = { 0 };
19265 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19267 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19269 memcpy (digest
, tmp_buf
, 16);
19271 digest
[0] = byte_swap_32 (digest
[0]);
19272 digest
[1] = byte_swap_32 (digest
[1]);
19273 digest
[2] = byte_swap_32 (digest
[2]);
19274 digest
[3] = byte_swap_32 (digest
[3]);
19276 // add some stuff to normal salt to make sorted happy
19278 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19279 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19280 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19281 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19282 salt
->salt_buf
[4] = salt
->salt_iter
;
19284 return (PARSER_OK
);
19287 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19289 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19291 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19293 u64
*digest
= (u64
*) hash_buf
->digest
;
19295 salt_t
*salt
= hash_buf
->salt
;
19297 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19305 char *iter_pos
= input_buf
+ 7;
19307 u32 iter
= atoi (iter_pos
);
19309 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19310 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19312 // first is *raw* salt
19314 char *salt_pos
= strchr (iter_pos
, ':');
19316 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19320 char *hash_pos
= strchr (salt_pos
, ':');
19322 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19324 u32 salt_len
= hash_pos
- salt_pos
;
19326 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19330 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19332 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19336 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19338 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19340 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19342 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19343 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19345 salt
->salt_len
= salt_len
;
19346 salt
->salt_iter
= iter
- 1;
19350 u8 tmp_buf
[100] = { 0 };
19352 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19354 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19356 memcpy (digest
, tmp_buf
, 64);
19358 digest
[0] = byte_swap_64 (digest
[0]);
19359 digest
[1] = byte_swap_64 (digest
[1]);
19360 digest
[2] = byte_swap_64 (digest
[2]);
19361 digest
[3] = byte_swap_64 (digest
[3]);
19362 digest
[4] = byte_swap_64 (digest
[4]);
19363 digest
[5] = byte_swap_64 (digest
[5]);
19364 digest
[6] = byte_swap_64 (digest
[6]);
19365 digest
[7] = byte_swap_64 (digest
[7]);
19367 // add some stuff to normal salt to make sorted happy
19369 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19370 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19371 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19372 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19373 salt
->salt_buf
[4] = salt
->salt_iter
;
19375 return (PARSER_OK
);
19378 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19380 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19382 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19384 uint
*digest
= (uint
*) hash_buf
->digest
;
19386 salt_t
*salt
= hash_buf
->salt
;
19392 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19394 char *hash_pos
= strchr (salt_pos
, '$');
19396 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19398 u32 salt_len
= hash_pos
- salt_pos
;
19400 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19404 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19406 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19410 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19411 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19429 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19430 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19432 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19433 salt
->salt_len
= 8;
19435 return (PARSER_OK
);
19438 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19440 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19442 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19444 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19446 if (c19
& 3) return (PARSER_HASH_VALUE
);
19448 salt_t
*salt
= hash_buf
->salt
;
19450 u32
*digest
= (u32
*) hash_buf
->digest
;
19454 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19455 | itoa64_to_int (input_buf
[2]) << 6
19456 | itoa64_to_int (input_buf
[3]) << 12
19457 | itoa64_to_int (input_buf
[4]) << 18;
19461 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19462 | itoa64_to_int (input_buf
[6]) << 6
19463 | itoa64_to_int (input_buf
[7]) << 12
19464 | itoa64_to_int (input_buf
[8]) << 18;
19466 salt
->salt_len
= 4;
19468 u8 tmp_buf
[100] = { 0 };
19470 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19472 memcpy (digest
, tmp_buf
, 8);
19476 IP (digest
[0], digest
[1], tt
);
19478 digest
[0] = rotr32 (digest
[0], 31);
19479 digest
[1] = rotr32 (digest
[1], 31);
19483 return (PARSER_OK
);
19486 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19488 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19490 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19492 u32
*digest
= (u32
*) hash_buf
->digest
;
19494 salt_t
*salt
= hash_buf
->salt
;
19500 char *type_pos
= input_buf
+ 6 + 1;
19502 char *salt_pos
= strchr (type_pos
, '*');
19504 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19506 u32 type_len
= salt_pos
- type_pos
;
19508 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19512 char *crypted_pos
= strchr (salt_pos
, '*');
19514 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19516 u32 salt_len
= crypted_pos
- salt_pos
;
19518 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19522 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19524 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19530 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19531 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19533 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19534 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19536 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19537 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19538 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19539 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19541 salt
->salt_len
= 24;
19542 salt
->salt_iter
= ROUNDS_RAR3
;
19544 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19545 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19547 digest
[0] = 0xc43d7b00;
19548 digest
[1] = 0x40070000;
19552 return (PARSER_OK
);
19555 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19557 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19559 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19561 u32
*digest
= (u32
*) hash_buf
->digest
;
19563 salt_t
*salt
= hash_buf
->salt
;
19565 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19571 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19573 char *param1_pos
= strchr (param0_pos
, '$');
19575 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19577 u32 param0_len
= param1_pos
- param0_pos
;
19581 char *param2_pos
= strchr (param1_pos
, '$');
19583 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19585 u32 param1_len
= param2_pos
- param1_pos
;
19589 char *param3_pos
= strchr (param2_pos
, '$');
19591 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19593 u32 param2_len
= param3_pos
- param2_pos
;
19597 char *param4_pos
= strchr (param3_pos
, '$');
19599 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19601 u32 param3_len
= param4_pos
- param3_pos
;
19605 char *param5_pos
= strchr (param4_pos
, '$');
19607 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19609 u32 param4_len
= param5_pos
- param4_pos
;
19613 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19615 char *salt_buf
= param1_pos
;
19616 char *iv
= param3_pos
;
19617 char *pswcheck
= param5_pos
;
19619 const uint salt_len
= atoi (param0_pos
);
19620 const uint iterations
= atoi (param2_pos
);
19621 const uint pswcheck_len
= atoi (param4_pos
);
19627 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19628 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19629 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19631 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19632 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19633 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19639 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19640 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19641 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19642 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19644 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19645 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19646 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19647 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19649 salt
->salt_len
= 16;
19651 salt
->salt_sign
[0] = iterations
;
19653 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19659 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19660 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19664 return (PARSER_OK
);
19667 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19669 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19671 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19673 u32
*digest
= (u32
*) hash_buf
->digest
;
19675 salt_t
*salt
= hash_buf
->salt
;
19677 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19684 char *account_pos
= input_buf
+ 11 + 1;
19690 if (account_pos
[0] == '*')
19694 data_pos
= strchr (account_pos
, '*');
19699 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19701 uint account_len
= data_pos
- account_pos
+ 1;
19703 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19708 data_len
= input_len
- 11 - 1 - account_len
- 2;
19710 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19714 /* assume $krb5tgs$23$checksum$edata2 */
19715 data_pos
= account_pos
;
19717 memcpy (krb5tgs
->account_info
, "**", 3);
19719 data_len
= input_len
- 11 - 1 - 1;
19722 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19724 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19726 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19728 const char p0
= data_pos
[i
+ 0];
19729 const char p1
= data_pos
[i
+ 1];
19731 *checksum_ptr
++ = hex_convert (p1
) << 0
19732 | hex_convert (p0
) << 4;
19735 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19737 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19740 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19742 const char p0
= data_pos
[i
+ 0];
19743 const char p1
= data_pos
[i
+ 1];
19744 *edata_ptr
++ = hex_convert (p1
) << 0
19745 | hex_convert (p0
) << 4;
19748 /* this is needed for hmac_md5 */
19749 *edata_ptr
++ = 0x80;
19751 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19752 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19753 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19754 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19756 salt
->salt_len
= 32;
19758 digest
[0] = krb5tgs
->checksum
[0];
19759 digest
[1] = krb5tgs
->checksum
[1];
19760 digest
[2] = krb5tgs
->checksum
[2];
19761 digest
[3] = krb5tgs
->checksum
[3];
19763 return (PARSER_OK
);
19766 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19768 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19770 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19772 u32
*digest
= (u32
*) hash_buf
->digest
;
19774 salt_t
*salt
= hash_buf
->salt
;
19781 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19785 char *wrapped_key_pos
;
19789 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19791 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19793 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19795 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19800 data_pos
= salt_pos
;
19802 wrapped_key_pos
= strchr (salt_pos
, '*');
19804 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19806 uint salt_len
= wrapped_key_pos
- salt_pos
;
19808 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19813 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19815 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19817 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19818 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19819 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19820 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19824 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19825 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19826 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19827 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19828 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19829 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19831 salt
->salt_len
= 40;
19833 digest
[0] = salt
->salt_buf
[0];
19834 digest
[1] = salt
->salt_buf
[1];
19835 digest
[2] = salt
->salt_buf
[2];
19836 digest
[3] = salt
->salt_buf
[3];
19838 return (PARSER_OK
);
19841 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19843 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19845 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19847 u32
*digest
= (u32
*) hash_buf
->digest
;
19849 salt_t
*salt
= hash_buf
->salt
;
19851 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19861 char *algorithm_pos
;
19863 char *final_random_seed_pos
;
19864 u32 final_random_seed_len
;
19866 char *transf_random_seed_pos
;
19867 u32 transf_random_seed_len
;
19872 /* default is no keyfile provided */
19873 char *keyfile_len_pos
;
19874 u32 keyfile_len
= 0;
19875 u32 is_keyfile_present
= 0;
19876 char *keyfile_inline_pos
;
19879 /* specific to version 1 */
19880 char *contents_len_pos
;
19882 char *contents_pos
;
19884 /* specific to version 2 */
19885 char *expected_bytes_pos
;
19886 u32 expected_bytes_len
;
19888 char *contents_hash_pos
;
19889 u32 contents_hash_len
;
19891 version_pos
= input_buf
+ 8 + 1 + 1;
19893 keepass
->version
= atoi (version_pos
);
19895 rounds_pos
= strchr (version_pos
, '*');
19897 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19901 salt
->salt_iter
= (atoi (rounds_pos
));
19903 algorithm_pos
= strchr (rounds_pos
, '*');
19905 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19909 keepass
->algorithm
= atoi (algorithm_pos
);
19911 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19913 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19915 final_random_seed_pos
++;
19917 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19918 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19919 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19920 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19922 if (keepass
->version
== 2)
19924 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19925 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19926 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19927 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19930 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19932 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19934 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19936 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19937 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19939 transf_random_seed_pos
++;
19941 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19942 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19943 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19944 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19945 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19946 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19947 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19948 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19950 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19952 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19954 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19956 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19960 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19961 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19962 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19963 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19965 if (keepass
->version
== 1)
19967 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19969 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19971 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19973 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19975 contents_hash_pos
++;
19977 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19978 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19979 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19980 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19981 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19982 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19983 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19984 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19986 /* get length of contents following */
19987 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19989 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19991 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19993 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19997 u32 inline_flag
= atoi (inline_flag_pos
);
19999 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
20001 contents_len_pos
= strchr (inline_flag_pos
, '*');
20003 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20005 contents_len_pos
++;
20007 contents_len
= atoi (contents_len_pos
);
20009 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
20011 contents_pos
= strchr (contents_len_pos
, '*');
20013 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20019 keepass
->contents_len
= contents_len
;
20021 contents_len
= contents_len
/ 4;
20023 keyfile_inline_pos
= strchr (contents_pos
, '*');
20025 u32 real_contents_len
;
20027 if (keyfile_inline_pos
== NULL
)
20028 real_contents_len
= input_len
- (contents_pos
- input_buf
);
20031 real_contents_len
= keyfile_inline_pos
- contents_pos
;
20032 keyfile_inline_pos
++;
20033 is_keyfile_present
= 1;
20036 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
20038 for (i
= 0; i
< contents_len
; i
++)
20039 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
20041 else if (keepass
->version
== 2)
20043 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
20045 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20047 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
20049 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
20051 expected_bytes_pos
++;
20053 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
20054 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
20055 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
20056 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
20057 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
20058 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
20059 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
20060 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
20062 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
20064 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20066 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
20068 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
20070 contents_hash_pos
++;
20072 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
20073 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
20074 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
20075 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
20076 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
20077 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
20078 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
20079 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
20081 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
20083 if (keyfile_inline_pos
== NULL
)
20084 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
20087 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
20088 keyfile_inline_pos
++;
20089 is_keyfile_present
= 1;
20091 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
20094 if (is_keyfile_present
!= 0)
20096 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
20100 keyfile_len
= atoi (keyfile_len_pos
);
20102 keepass
->keyfile_len
= keyfile_len
;
20104 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20106 keyfile_pos
= strchr (keyfile_len_pos
, '*');
20108 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
20112 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
20114 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
20116 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
20117 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
20118 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
20119 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
20120 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
20121 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
20122 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
20123 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
20126 digest
[0] = keepass
->enc_iv
[0];
20127 digest
[1] = keepass
->enc_iv
[1];
20128 digest
[2] = keepass
->enc_iv
[2];
20129 digest
[3] = keepass
->enc_iv
[3];
20131 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20132 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20133 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20134 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20135 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20136 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20137 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20138 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20140 return (PARSER_OK
);
20143 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20145 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20147 u32
*digest
= (u32
*) hash_buf
->digest
;
20149 salt_t
*salt
= hash_buf
->salt
;
20151 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20152 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20153 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20154 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20155 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20156 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20157 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20158 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20160 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20162 uint salt_len
= input_len
- 64 - 1;
20164 char *salt_buf
= input_buf
+ 64 + 1;
20166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20170 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20172 salt
->salt_len
= salt_len
;
20175 * we can precompute the first sha256 transform
20178 uint w
[16] = { 0 };
20180 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20181 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20182 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20183 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20184 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20185 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20186 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20187 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20188 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20189 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20190 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20191 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20192 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20193 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20194 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20195 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20197 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20199 sha256_64 (w
, pc256
);
20201 salt
->salt_buf_pc
[0] = pc256
[0];
20202 salt
->salt_buf_pc
[1] = pc256
[1];
20203 salt
->salt_buf_pc
[2] = pc256
[2];
20204 salt
->salt_buf_pc
[3] = pc256
[3];
20205 salt
->salt_buf_pc
[4] = pc256
[4];
20206 salt
->salt_buf_pc
[5] = pc256
[5];
20207 salt
->salt_buf_pc
[6] = pc256
[6];
20208 salt
->salt_buf_pc
[7] = pc256
[7];
20210 digest
[0] -= pc256
[0];
20211 digest
[1] -= pc256
[1];
20212 digest
[2] -= pc256
[2];
20213 digest
[3] -= pc256
[3];
20214 digest
[4] -= pc256
[4];
20215 digest
[5] -= pc256
[5];
20216 digest
[6] -= pc256
[6];
20217 digest
[7] -= pc256
[7];
20219 return (PARSER_OK
);
20222 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20224 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20226 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20228 u32
*digest
= (u32
*) hash_buf
->digest
;
20230 salt_t
*salt
= hash_buf
->salt
;
20236 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20238 char *data_buf_pos
= strchr (data_len_pos
, '$');
20240 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20242 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20244 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20245 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20249 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20251 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20253 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20255 u32 data_len
= atoi (data_len_pos
);
20257 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20263 char *salt_pos
= data_buf_pos
;
20265 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20266 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20267 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20268 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20270 // this is actually the CT, which is also the hash later (if matched)
20272 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20273 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20274 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20275 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20277 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20279 salt
->salt_iter
= 10 - 1;
20285 digest
[0] = salt
->salt_buf
[4];
20286 digest
[1] = salt
->salt_buf
[5];
20287 digest
[2] = salt
->salt_buf
[6];
20288 digest
[3] = salt
->salt_buf
[7];
20290 return (PARSER_OK
);
20293 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20295 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20297 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20299 u32
*digest
= (u32
*) hash_buf
->digest
;
20301 salt_t
*salt
= hash_buf
->salt
;
20307 char *salt_pos
= input_buf
+ 11 + 1;
20309 char *iter_pos
= strchr (salt_pos
, ',');
20311 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20313 u32 salt_len
= iter_pos
- salt_pos
;
20315 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20319 char *hash_pos
= strchr (iter_pos
, ',');
20321 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20323 u32 iter_len
= hash_pos
- iter_pos
;
20325 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20329 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20331 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20337 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20338 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20339 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20340 salt
->salt_buf
[3] = 0x00018000;
20342 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20343 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20344 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20345 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20347 salt
->salt_len
= salt_len
/ 2;
20349 salt
->salt_iter
= atoi (iter_pos
) - 1;
20355 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20356 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20357 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20358 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20359 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20360 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20361 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20362 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20364 return (PARSER_OK
);
20367 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20369 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20371 u32
*digest
= (u32
*) hash_buf
->digest
;
20373 salt_t
*salt
= hash_buf
->salt
;
20379 char *hash_pos
= input_buf
+ 64;
20380 char *salt1_pos
= input_buf
+ 128;
20381 char *salt2_pos
= input_buf
;
20387 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20388 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20389 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20390 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20392 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20393 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20394 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20395 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20397 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20398 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20399 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20400 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20402 salt
->salt_len
= 48;
20404 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20410 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20411 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20412 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20413 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20414 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20415 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20416 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20417 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20419 return (PARSER_OK
);
20422 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20424 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20426 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20427 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20429 u32
*digest
= (u32
*) hash_buf
->digest
;
20431 salt_t
*salt
= hash_buf
->salt
;
20433 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20439 char *param0_pos
= input_buf
+ 6 + 1;
20441 char *param1_pos
= strchr (param0_pos
, '*');
20443 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20445 u32 param0_len
= param1_pos
- param0_pos
;
20449 char *param2_pos
= strchr (param1_pos
, '*');
20451 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20453 u32 param1_len
= param2_pos
- param1_pos
;
20457 char *param3_pos
= strchr (param2_pos
, '*');
20459 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20461 u32 param2_len
= param3_pos
- param2_pos
;
20465 char *param4_pos
= strchr (param3_pos
, '*');
20467 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20469 u32 param3_len
= param4_pos
- param3_pos
;
20473 char *param5_pos
= strchr (param4_pos
, '*');
20475 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20477 u32 param4_len
= param5_pos
- param4_pos
;
20481 char *param6_pos
= strchr (param5_pos
, '*');
20483 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20485 u32 param5_len
= param6_pos
- param5_pos
;
20489 char *param7_pos
= strchr (param6_pos
, '*');
20491 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20493 u32 param6_len
= param7_pos
- param6_pos
;
20497 char *param8_pos
= strchr (param7_pos
, '*');
20499 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20501 u32 param7_len
= param8_pos
- param7_pos
;
20505 const uint type
= atoi (param0_pos
);
20506 const uint mode
= atoi (param1_pos
);
20507 const uint magic
= atoi (param2_pos
);
20509 char *salt_buf
= param3_pos
;
20511 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20513 const uint compress_length
= atoi (param5_pos
);
20515 char *data_buf
= param6_pos
;
20516 char *auth
= param7_pos
;
20522 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20524 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20526 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20528 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20530 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20532 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20534 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20536 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20538 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20540 if (type
!= 0) return (PARSER_SALT_VALUE
);
20542 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20544 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20546 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20554 zip2
->magic
= magic
;
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] = 0;
20561 zip2
->salt_buf
[3] = 0;
20563 zip2
->salt_len
= 8;
20565 else if (mode
== 2)
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] = 0;
20572 zip2
->salt_len
= 12;
20574 else if (mode
== 3)
20576 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20577 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20578 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20579 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20581 zip2
->salt_len
= 16;
20584 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20585 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20586 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20587 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20589 zip2
->verify_bytes
= verify_bytes
;
20591 zip2
->compress_length
= compress_length
;
20593 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20595 for (uint i
= 0; i
< param6_len
; i
+= 2)
20597 const char p0
= data_buf
[i
+ 0];
20598 const char p1
= data_buf
[i
+ 1];
20600 *data_buf_ptr
++ = hex_convert (p1
) << 0
20601 | hex_convert (p0
) << 4;
20606 *data_buf_ptr
= 0x80;
20608 char *auth_ptr
= (char *) zip2
->auth_buf
;
20610 for (uint i
= 0; i
< param7_len
; i
+= 2)
20612 const char p0
= auth
[i
+ 0];
20613 const char p1
= auth
[i
+ 1];
20615 *auth_ptr
++ = hex_convert (p1
) << 0
20616 | hex_convert (p0
) << 4;
20625 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20626 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20627 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20628 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20629 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20630 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20631 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20632 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20634 salt
->salt_len
= 32;
20636 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20639 * digest buf (fake)
20642 digest
[0] = zip2
->auth_buf
[0];
20643 digest
[1] = zip2
->auth_buf
[1];
20644 digest
[2] = zip2
->auth_buf
[2];
20645 digest
[3] = zip2
->auth_buf
[3];
20647 return (PARSER_OK
);
20650 int win8phone_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20652 if ((input_len
< DISPLAY_LEN_MIN_13800
) || (input_len
> DISPLAY_LEN_MAX_13800
)) return (PARSER_GLOBAL_LENGTH
);
20654 u32
*digest
= (u32
*) hash_buf
->digest
;
20656 salt_t
*salt
= hash_buf
->salt
;
20658 win8phone_t
*esalt
= hash_buf
->esalt
;
20660 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20661 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20662 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20663 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20664 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20665 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20666 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20667 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20669 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20671 char *salt_buf_ptr
= input_buf
+ 64 + 1;
20673 u32
*salt_buf
= esalt
->salt_buf
;
20675 for (int i
= 0, j
= 0; i
< 32; i
+= 1, j
+= 8)
20677 salt_buf
[i
] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[j
]);
20680 salt
->salt_buf
[0] = salt_buf
[0];
20681 salt
->salt_buf
[1] = salt_buf
[1];
20682 salt
->salt_buf
[2] = salt_buf
[2];
20683 salt
->salt_buf
[3] = salt_buf
[3];
20684 salt
->salt_buf
[4] = salt_buf
[4];
20685 salt
->salt_buf
[5] = salt_buf
[5];
20686 salt
->salt_buf
[6] = salt_buf
[6];
20687 salt
->salt_buf
[7] = salt_buf
[7];
20689 salt
->salt_len
= 64;
20691 return (PARSER_OK
);
20695 * parallel running threads
20700 BOOL WINAPI
sigHandler_default (DWORD sig
)
20704 case CTRL_CLOSE_EVENT
:
20707 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20708 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20709 * function otherwise it is too late (e.g. after returning from this function)
20714 SetConsoleCtrlHandler (NULL
, TRUE
);
20721 case CTRL_LOGOFF_EVENT
:
20722 case CTRL_SHUTDOWN_EVENT
:
20726 SetConsoleCtrlHandler (NULL
, TRUE
);
20734 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20738 case CTRL_CLOSE_EVENT
:
20742 SetConsoleCtrlHandler (NULL
, TRUE
);
20749 case CTRL_LOGOFF_EVENT
:
20750 case CTRL_SHUTDOWN_EVENT
:
20754 SetConsoleCtrlHandler (NULL
, TRUE
);
20762 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20764 if (callback
== NULL
)
20766 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20770 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20776 void sigHandler_default (int sig
)
20780 signal (sig
, NULL
);
20783 void sigHandler_benchmark (int sig
)
20787 signal (sig
, NULL
);
20790 void hc_signal (void (callback
) (int))
20792 if (callback
== NULL
) callback
= SIG_DFL
;
20794 signal (SIGINT
, callback
);
20795 signal (SIGTERM
, callback
);
20796 signal (SIGABRT
, callback
);
20801 void status_display ();
20803 void *thread_keypress (void *p
)
20805 uint quiet
= data
.quiet
;
20809 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20811 int ch
= tty_getchar();
20813 if (ch
== -1) break;
20815 if (ch
== 0) continue;
20817 //https://github.com/hashcat/hashcat/issues/302
20822 hc_thread_mutex_lock (mux_display
);
20838 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20839 if (quiet
== 0) fflush (stdout
);
20851 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20852 if (quiet
== 0) fflush (stdout
);
20864 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20865 if (quiet
== 0) fflush (stdout
);
20877 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20878 if (quiet
== 0) fflush (stdout
);
20886 stop_at_checkpoint ();
20890 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20891 if (quiet
== 0) fflush (stdout
);
20904 //https://github.com/hashcat/hashcat/issues/302
20909 hc_thread_mutex_unlock (mux_display
);
20921 bool class_num (const u8 c
)
20923 return ((c
>= '0') && (c
<= '9'));
20926 bool class_lower (const u8 c
)
20928 return ((c
>= 'a') && (c
<= 'z'));
20931 bool class_upper (const u8 c
)
20933 return ((c
>= 'A') && (c
<= 'Z'));
20936 bool class_alpha (const u8 c
)
20938 return (class_lower (c
) || class_upper (c
));
20941 int conv_ctoi (const u8 c
)
20947 else if (class_upper (c
))
20949 return c
- 'A' + 10;
20955 int conv_itoc (const u8 c
)
20963 return c
+ 'A' - 10;
20973 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20974 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20975 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20976 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20977 #define MAX_KERNEL_RULES 255
20978 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20979 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20980 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20982 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20983 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20984 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20985 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20987 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20992 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20994 switch (rule_buf
[rule_pos
])
21000 case RULE_OP_MANGLE_NOOP
:
21001 SET_NAME (rule
, rule_buf
[rule_pos
]);
21004 case RULE_OP_MANGLE_LREST
:
21005 SET_NAME (rule
, rule_buf
[rule_pos
]);
21008 case RULE_OP_MANGLE_UREST
:
21009 SET_NAME (rule
, rule_buf
[rule_pos
]);
21012 case RULE_OP_MANGLE_LREST_UFIRST
:
21013 SET_NAME (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_UREST_LFIRST
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21020 case RULE_OP_MANGLE_TREST
:
21021 SET_NAME (rule
, rule_buf
[rule_pos
]);
21024 case RULE_OP_MANGLE_TOGGLE_AT
:
21025 SET_NAME (rule
, rule_buf
[rule_pos
]);
21026 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21029 case RULE_OP_MANGLE_REVERSE
:
21030 SET_NAME (rule
, rule_buf
[rule_pos
]);
21033 case RULE_OP_MANGLE_DUPEWORD
:
21034 SET_NAME (rule
, rule_buf
[rule_pos
]);
21037 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21038 SET_NAME (rule
, rule_buf
[rule_pos
]);
21039 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21042 case RULE_OP_MANGLE_REFLECT
:
21043 SET_NAME (rule
, rule_buf
[rule_pos
]);
21046 case RULE_OP_MANGLE_ROTATE_LEFT
:
21047 SET_NAME (rule
, rule_buf
[rule_pos
]);
21050 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21051 SET_NAME (rule
, rule_buf
[rule_pos
]);
21054 case RULE_OP_MANGLE_APPEND
:
21055 SET_NAME (rule
, rule_buf
[rule_pos
]);
21056 SET_P0 (rule
, rule_buf
[rule_pos
]);
21059 case RULE_OP_MANGLE_PREPEND
:
21060 SET_NAME (rule
, rule_buf
[rule_pos
]);
21061 SET_P0 (rule
, rule_buf
[rule_pos
]);
21064 case RULE_OP_MANGLE_DELETE_FIRST
:
21065 SET_NAME (rule
, rule_buf
[rule_pos
]);
21068 case RULE_OP_MANGLE_DELETE_LAST
:
21069 SET_NAME (rule
, rule_buf
[rule_pos
]);
21072 case RULE_OP_MANGLE_DELETE_AT
:
21073 SET_NAME (rule
, rule_buf
[rule_pos
]);
21074 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21077 case RULE_OP_MANGLE_EXTRACT
:
21078 SET_NAME (rule
, rule_buf
[rule_pos
]);
21079 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21080 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21083 case RULE_OP_MANGLE_OMIT
:
21084 SET_NAME (rule
, rule_buf
[rule_pos
]);
21085 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21086 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21089 case RULE_OP_MANGLE_INSERT
:
21090 SET_NAME (rule
, rule_buf
[rule_pos
]);
21091 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21092 SET_P1 (rule
, rule_buf
[rule_pos
]);
21095 case RULE_OP_MANGLE_OVERSTRIKE
:
21096 SET_NAME (rule
, rule_buf
[rule_pos
]);
21097 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21098 SET_P1 (rule
, rule_buf
[rule_pos
]);
21101 case RULE_OP_MANGLE_TRUNCATE_AT
:
21102 SET_NAME (rule
, rule_buf
[rule_pos
]);
21103 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21106 case RULE_OP_MANGLE_REPLACE
:
21107 SET_NAME (rule
, rule_buf
[rule_pos
]);
21108 SET_P0 (rule
, rule_buf
[rule_pos
]);
21109 SET_P1 (rule
, rule_buf
[rule_pos
]);
21112 case RULE_OP_MANGLE_PURGECHAR
:
21116 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21120 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21121 SET_NAME (rule
, rule_buf
[rule_pos
]);
21122 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21125 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21126 SET_NAME (rule
, rule_buf
[rule_pos
]);
21127 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21130 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21131 SET_NAME (rule
, rule_buf
[rule_pos
]);
21134 case RULE_OP_MANGLE_SWITCH_FIRST
:
21135 SET_NAME (rule
, rule_buf
[rule_pos
]);
21138 case RULE_OP_MANGLE_SWITCH_LAST
:
21139 SET_NAME (rule
, rule_buf
[rule_pos
]);
21142 case RULE_OP_MANGLE_SWITCH_AT
:
21143 SET_NAME (rule
, rule_buf
[rule_pos
]);
21144 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21145 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
21148 case RULE_OP_MANGLE_CHR_SHIFTL
:
21149 SET_NAME (rule
, rule_buf
[rule_pos
]);
21150 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21153 case RULE_OP_MANGLE_CHR_SHIFTR
:
21154 SET_NAME (rule
, rule_buf
[rule_pos
]);
21155 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21158 case RULE_OP_MANGLE_CHR_INCR
:
21159 SET_NAME (rule
, rule_buf
[rule_pos
]);
21160 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21163 case RULE_OP_MANGLE_CHR_DECR
:
21164 SET_NAME (rule
, rule_buf
[rule_pos
]);
21165 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21168 case RULE_OP_MANGLE_REPLACE_NP1
:
21169 SET_NAME (rule
, rule_buf
[rule_pos
]);
21170 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21173 case RULE_OP_MANGLE_REPLACE_NM1
:
21174 SET_NAME (rule
, rule_buf
[rule_pos
]);
21175 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21178 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21179 SET_NAME (rule
, rule_buf
[rule_pos
]);
21180 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21183 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21184 SET_NAME (rule
, rule_buf
[rule_pos
]);
21185 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21188 case RULE_OP_MANGLE_TITLE
:
21189 SET_NAME (rule
, rule_buf
[rule_pos
]);
21198 if (rule_pos
< rule_len
) return (-1);
21203 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21207 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21211 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21215 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21219 case RULE_OP_MANGLE_NOOP
:
21220 rule_buf
[rule_pos
] = rule_cmd
;
21223 case RULE_OP_MANGLE_LREST
:
21224 rule_buf
[rule_pos
] = rule_cmd
;
21227 case RULE_OP_MANGLE_UREST
:
21228 rule_buf
[rule_pos
] = rule_cmd
;
21231 case RULE_OP_MANGLE_LREST_UFIRST
:
21232 rule_buf
[rule_pos
] = rule_cmd
;
21235 case RULE_OP_MANGLE_UREST_LFIRST
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21239 case RULE_OP_MANGLE_TREST
:
21240 rule_buf
[rule_pos
] = rule_cmd
;
21243 case RULE_OP_MANGLE_TOGGLE_AT
:
21244 rule_buf
[rule_pos
] = rule_cmd
;
21245 GET_P0_CONV (rule
);
21248 case RULE_OP_MANGLE_REVERSE
:
21249 rule_buf
[rule_pos
] = rule_cmd
;
21252 case RULE_OP_MANGLE_DUPEWORD
:
21253 rule_buf
[rule_pos
] = rule_cmd
;
21256 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21257 rule_buf
[rule_pos
] = rule_cmd
;
21258 GET_P0_CONV (rule
);
21261 case RULE_OP_MANGLE_REFLECT
:
21262 rule_buf
[rule_pos
] = rule_cmd
;
21265 case RULE_OP_MANGLE_ROTATE_LEFT
:
21266 rule_buf
[rule_pos
] = rule_cmd
;
21269 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21270 rule_buf
[rule_pos
] = rule_cmd
;
21273 case RULE_OP_MANGLE_APPEND
:
21274 rule_buf
[rule_pos
] = rule_cmd
;
21278 case RULE_OP_MANGLE_PREPEND
:
21279 rule_buf
[rule_pos
] = rule_cmd
;
21283 case RULE_OP_MANGLE_DELETE_FIRST
:
21284 rule_buf
[rule_pos
] = rule_cmd
;
21287 case RULE_OP_MANGLE_DELETE_LAST
:
21288 rule_buf
[rule_pos
] = rule_cmd
;
21291 case RULE_OP_MANGLE_DELETE_AT
:
21292 rule_buf
[rule_pos
] = rule_cmd
;
21293 GET_P0_CONV (rule
);
21296 case RULE_OP_MANGLE_EXTRACT
:
21297 rule_buf
[rule_pos
] = rule_cmd
;
21298 GET_P0_CONV (rule
);
21299 GET_P1_CONV (rule
);
21302 case RULE_OP_MANGLE_OMIT
:
21303 rule_buf
[rule_pos
] = rule_cmd
;
21304 GET_P0_CONV (rule
);
21305 GET_P1_CONV (rule
);
21308 case RULE_OP_MANGLE_INSERT
:
21309 rule_buf
[rule_pos
] = rule_cmd
;
21310 GET_P0_CONV (rule
);
21314 case RULE_OP_MANGLE_OVERSTRIKE
:
21315 rule_buf
[rule_pos
] = rule_cmd
;
21316 GET_P0_CONV (rule
);
21320 case RULE_OP_MANGLE_TRUNCATE_AT
:
21321 rule_buf
[rule_pos
] = rule_cmd
;
21322 GET_P0_CONV (rule
);
21325 case RULE_OP_MANGLE_REPLACE
:
21326 rule_buf
[rule_pos
] = rule_cmd
;
21331 case RULE_OP_MANGLE_PURGECHAR
:
21335 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21339 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21340 rule_buf
[rule_pos
] = rule_cmd
;
21341 GET_P0_CONV (rule
);
21344 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21345 rule_buf
[rule_pos
] = rule_cmd
;
21346 GET_P0_CONV (rule
);
21349 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21350 rule_buf
[rule_pos
] = rule_cmd
;
21353 case RULE_OP_MANGLE_SWITCH_FIRST
:
21354 rule_buf
[rule_pos
] = rule_cmd
;
21357 case RULE_OP_MANGLE_SWITCH_LAST
:
21358 rule_buf
[rule_pos
] = rule_cmd
;
21361 case RULE_OP_MANGLE_SWITCH_AT
:
21362 rule_buf
[rule_pos
] = rule_cmd
;
21363 GET_P0_CONV (rule
);
21364 GET_P1_CONV (rule
);
21367 case RULE_OP_MANGLE_CHR_SHIFTL
:
21368 rule_buf
[rule_pos
] = rule_cmd
;
21369 GET_P0_CONV (rule
);
21372 case RULE_OP_MANGLE_CHR_SHIFTR
:
21373 rule_buf
[rule_pos
] = rule_cmd
;
21374 GET_P0_CONV (rule
);
21377 case RULE_OP_MANGLE_CHR_INCR
:
21378 rule_buf
[rule_pos
] = rule_cmd
;
21379 GET_P0_CONV (rule
);
21382 case RULE_OP_MANGLE_CHR_DECR
:
21383 rule_buf
[rule_pos
] = rule_cmd
;
21384 GET_P0_CONV (rule
);
21387 case RULE_OP_MANGLE_REPLACE_NP1
:
21388 rule_buf
[rule_pos
] = rule_cmd
;
21389 GET_P0_CONV (rule
);
21392 case RULE_OP_MANGLE_REPLACE_NM1
:
21393 rule_buf
[rule_pos
] = rule_cmd
;
21394 GET_P0_CONV (rule
);
21397 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21398 rule_buf
[rule_pos
] = rule_cmd
;
21399 GET_P0_CONV (rule
);
21402 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21403 rule_buf
[rule_pos
] = rule_cmd
;
21404 GET_P0_CONV (rule
);
21407 case RULE_OP_MANGLE_TITLE
:
21408 rule_buf
[rule_pos
] = rule_cmd
;
21412 return rule_pos
- 1;
21430 * CPU rules : this is from hashcat sources, cpu based rules
21433 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21434 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21436 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21437 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21438 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21440 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21441 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21442 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21444 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21448 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21453 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21457 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21462 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21466 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21471 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21476 for (l
= 0; l
< arr_len
; l
++)
21478 r
= arr_len
- 1 - l
;
21482 MANGLE_SWITCH (arr
, l
, r
);
21488 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21490 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21492 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21494 return (arr_len
* 2);
21497 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21499 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21501 int orig_len
= arr_len
;
21505 for (i
= 0; i
< times
; i
++)
21507 memcpy (&arr
[arr_len
], arr
, orig_len
);
21509 arr_len
+= orig_len
;
21515 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21517 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21519 mangle_double (arr
, arr_len
);
21521 mangle_reverse (arr
+ arr_len
, arr_len
);
21523 return (arr_len
* 2);
21526 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21531 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21533 MANGLE_SWITCH (arr
, l
, r
);
21539 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21544 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21546 MANGLE_SWITCH (arr
, l
, r
);
21552 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21554 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21558 return (arr_len
+ 1);
21561 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21563 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21567 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21569 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21574 return (arr_len
+ 1);
21577 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21579 if (upos
>= arr_len
) return (arr_len
);
21583 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21585 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21588 return (arr_len
- 1);
21591 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21593 if (upos
>= arr_len
) return (arr_len
);
21595 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21599 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21601 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21607 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21609 if (upos
>= arr_len
) return (arr_len
);
21611 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21615 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21617 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21620 return (arr_len
- ulen
);
21623 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21625 if (upos
>= arr_len
) return (arr_len
);
21627 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21631 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21633 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21638 return (arr_len
+ 1);
21641 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
)
21643 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21645 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21647 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21649 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21651 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21653 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21655 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21657 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21659 return (arr_len
+ arr2_cpy
);
21662 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21664 if (upos
>= arr_len
) return (arr_len
);
21671 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21673 if (upos
>= arr_len
) return (arr_len
);
21675 memset (arr
+ upos
, 0, arr_len
- upos
);
21680 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21684 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21686 if (arr
[arr_pos
] != oldc
) continue;
21688 arr
[arr_pos
] = newc
;
21694 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21700 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21702 if (arr
[arr_pos
] == c
) continue;
21704 arr
[ret_len
] = arr
[arr_pos
];
21712 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21714 if (ulen
> arr_len
) return (arr_len
);
21716 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21718 char cs
[100] = { 0 };
21720 memcpy (cs
, arr
, ulen
);
21724 for (i
= 0; i
< ulen
; i
++)
21728 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21734 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21736 if (ulen
> arr_len
) return (arr_len
);
21738 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21740 int upos
= arr_len
- ulen
;
21744 for (i
= 0; i
< ulen
; i
++)
21746 char c
= arr
[upos
+ i
];
21748 arr_len
= mangle_append (arr
, arr_len
, c
);
21754 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21756 if ( arr_len
== 0) return (arr_len
);
21757 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21759 char c
= arr
[upos
];
21763 for (i
= 0; i
< ulen
; i
++)
21765 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21771 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21773 if ( arr_len
== 0) return (arr_len
);
21774 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21778 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21780 int new_pos
= arr_pos
* 2;
21782 arr
[new_pos
] = arr
[arr_pos
];
21784 arr
[new_pos
+ 1] = arr
[arr_pos
];
21787 return (arr_len
* 2);
21790 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21792 if (upos
>= arr_len
) return (arr_len
);
21793 if (upos2
>= arr_len
) return (arr_len
);
21795 MANGLE_SWITCH (arr
, upos
, upos2
);
21800 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21802 MANGLE_SWITCH (arr
, upos
, upos2
);
21807 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21809 if (upos
>= arr_len
) return (arr_len
);
21816 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21818 if (upos
>= arr_len
) return (arr_len
);
21825 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21827 if (upos
>= arr_len
) return (arr_len
);
21834 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21836 if (upos
>= arr_len
) return (arr_len
);
21843 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21845 int upper_next
= 1;
21849 for (pos
= 0; pos
< arr_len
; pos
++)
21851 if (arr
[pos
] == ' ')
21862 MANGLE_UPPER_AT (arr
, pos
);
21866 MANGLE_LOWER_AT (arr
, pos
);
21873 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21875 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21881 for (j
= 0; j
< rp_gen_num
; j
++)
21888 switch ((char) get_random_num (0, 9))
21891 r
= get_random_num (0, sizeof (grp_op_nop
));
21892 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21896 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21897 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21898 p1
= get_random_num (0, sizeof (grp_pos
));
21899 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21903 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21904 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21905 p1
= get_random_num (1, 6);
21906 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21910 r
= get_random_num (0, sizeof (grp_op_chr
));
21911 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21912 p1
= get_random_num (0x20, 0x7e);
21913 rule_buf
[rule_pos
++] = (char) p1
;
21917 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21918 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21919 p1
= get_random_num (0x20, 0x7e);
21920 rule_buf
[rule_pos
++] = (char) p1
;
21921 p2
= get_random_num (0x20, 0x7e);
21923 p2
= get_random_num (0x20, 0x7e);
21924 rule_buf
[rule_pos
++] = (char) p2
;
21928 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21929 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21930 p1
= get_random_num (0, sizeof (grp_pos
));
21931 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21932 p2
= get_random_num (0x20, 0x7e);
21933 rule_buf
[rule_pos
++] = (char) p2
;
21937 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21938 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21939 p1
= get_random_num (0, sizeof (grp_pos
));
21940 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21941 p2
= get_random_num (0, sizeof (grp_pos
));
21943 p2
= get_random_num (0, sizeof (grp_pos
));
21944 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21948 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21949 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21950 p1
= get_random_num (0, sizeof (grp_pos
));
21951 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21952 p2
= get_random_num (1, sizeof (grp_pos
));
21954 p2
= get_random_num (1, sizeof (grp_pos
));
21955 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21959 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21960 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21961 p1
= get_random_num (0, sizeof (grp_pos
));
21962 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21963 p2
= get_random_num (1, sizeof (grp_pos
));
21964 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21965 p3
= get_random_num (0, sizeof (grp_pos
));
21966 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21974 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21976 char mem
[BLOCK_SIZE
] = { 0 };
21978 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21980 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21982 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21984 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21986 int out_len
= in_len
;
21987 int mem_len
= in_len
;
21989 memcpy (out
, in
, out_len
);
21993 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21998 switch (rule
[rule_pos
])
22003 case RULE_OP_MANGLE_NOOP
:
22006 case RULE_OP_MANGLE_LREST
:
22007 out_len
= mangle_lrest (out
, out_len
);
22010 case RULE_OP_MANGLE_UREST
:
22011 out_len
= mangle_urest (out
, out_len
);
22014 case RULE_OP_MANGLE_LREST_UFIRST
:
22015 out_len
= mangle_lrest (out
, out_len
);
22016 if (out_len
) MANGLE_UPPER_AT (out
, 0);
22019 case RULE_OP_MANGLE_UREST_LFIRST
:
22020 out_len
= mangle_urest (out
, out_len
);
22021 if (out_len
) MANGLE_LOWER_AT (out
, 0);
22024 case RULE_OP_MANGLE_TREST
:
22025 out_len
= mangle_trest (out
, out_len
);
22028 case RULE_OP_MANGLE_TOGGLE_AT
:
22029 NEXT_RULEPOS (rule_pos
);
22030 NEXT_RPTOI (rule
, rule_pos
, upos
);
22031 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
22034 case RULE_OP_MANGLE_REVERSE
:
22035 out_len
= mangle_reverse (out
, out_len
);
22038 case RULE_OP_MANGLE_DUPEWORD
:
22039 out_len
= mangle_double (out
, out_len
);
22042 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
22043 NEXT_RULEPOS (rule_pos
);
22044 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22045 out_len
= mangle_double_times (out
, out_len
, ulen
);
22048 case RULE_OP_MANGLE_REFLECT
:
22049 out_len
= mangle_reflect (out
, out_len
);
22052 case RULE_OP_MANGLE_ROTATE_LEFT
:
22053 mangle_rotate_left (out
, out_len
);
22056 case RULE_OP_MANGLE_ROTATE_RIGHT
:
22057 mangle_rotate_right (out
, out_len
);
22060 case RULE_OP_MANGLE_APPEND
:
22061 NEXT_RULEPOS (rule_pos
);
22062 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
22065 case RULE_OP_MANGLE_PREPEND
:
22066 NEXT_RULEPOS (rule_pos
);
22067 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
22070 case RULE_OP_MANGLE_DELETE_FIRST
:
22071 out_len
= mangle_delete_at (out
, out_len
, 0);
22074 case RULE_OP_MANGLE_DELETE_LAST
:
22075 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
22078 case RULE_OP_MANGLE_DELETE_AT
:
22079 NEXT_RULEPOS (rule_pos
);
22080 NEXT_RPTOI (rule
, rule_pos
, upos
);
22081 out_len
= mangle_delete_at (out
, out_len
, upos
);
22084 case RULE_OP_MANGLE_EXTRACT
:
22085 NEXT_RULEPOS (rule_pos
);
22086 NEXT_RPTOI (rule
, rule_pos
, upos
);
22087 NEXT_RULEPOS (rule_pos
);
22088 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22089 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
22092 case RULE_OP_MANGLE_OMIT
:
22093 NEXT_RULEPOS (rule_pos
);
22094 NEXT_RPTOI (rule
, rule_pos
, upos
);
22095 NEXT_RULEPOS (rule_pos
);
22096 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22097 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
22100 case RULE_OP_MANGLE_INSERT
:
22101 NEXT_RULEPOS (rule_pos
);
22102 NEXT_RPTOI (rule
, rule_pos
, upos
);
22103 NEXT_RULEPOS (rule_pos
);
22104 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
22107 case RULE_OP_MANGLE_OVERSTRIKE
:
22108 NEXT_RULEPOS (rule_pos
);
22109 NEXT_RPTOI (rule
, rule_pos
, upos
);
22110 NEXT_RULEPOS (rule_pos
);
22111 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
22114 case RULE_OP_MANGLE_TRUNCATE_AT
:
22115 NEXT_RULEPOS (rule_pos
);
22116 NEXT_RPTOI (rule
, rule_pos
, upos
);
22117 out_len
= mangle_truncate_at (out
, out_len
, upos
);
22120 case RULE_OP_MANGLE_REPLACE
:
22121 NEXT_RULEPOS (rule_pos
);
22122 NEXT_RULEPOS (rule_pos
);
22123 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
22126 case RULE_OP_MANGLE_PURGECHAR
:
22127 NEXT_RULEPOS (rule_pos
);
22128 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
22131 case RULE_OP_MANGLE_TOGGLECASE_REC
:
22135 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
22136 NEXT_RULEPOS (rule_pos
);
22137 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22138 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
22141 case RULE_OP_MANGLE_DUPECHAR_LAST
:
22142 NEXT_RULEPOS (rule_pos
);
22143 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22144 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
22147 case RULE_OP_MANGLE_DUPECHAR_ALL
:
22148 out_len
= mangle_dupechar (out
, out_len
);
22151 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
22152 NEXT_RULEPOS (rule_pos
);
22153 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22154 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
22157 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
22158 NEXT_RULEPOS (rule_pos
);
22159 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22160 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22163 case RULE_OP_MANGLE_SWITCH_FIRST
:
22164 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22167 case RULE_OP_MANGLE_SWITCH_LAST
:
22168 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22171 case RULE_OP_MANGLE_SWITCH_AT
:
22172 NEXT_RULEPOS (rule_pos
);
22173 NEXT_RPTOI (rule
, rule_pos
, upos
);
22174 NEXT_RULEPOS (rule_pos
);
22175 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22176 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22179 case RULE_OP_MANGLE_CHR_SHIFTL
:
22180 NEXT_RULEPOS (rule_pos
);
22181 NEXT_RPTOI (rule
, rule_pos
, upos
);
22182 mangle_chr_shiftl (out
, out_len
, upos
);
22185 case RULE_OP_MANGLE_CHR_SHIFTR
:
22186 NEXT_RULEPOS (rule_pos
);
22187 NEXT_RPTOI (rule
, rule_pos
, upos
);
22188 mangle_chr_shiftr (out
, out_len
, upos
);
22191 case RULE_OP_MANGLE_CHR_INCR
:
22192 NEXT_RULEPOS (rule_pos
);
22193 NEXT_RPTOI (rule
, rule_pos
, upos
);
22194 mangle_chr_incr (out
, out_len
, upos
);
22197 case RULE_OP_MANGLE_CHR_DECR
:
22198 NEXT_RULEPOS (rule_pos
);
22199 NEXT_RPTOI (rule
, rule_pos
, upos
);
22200 mangle_chr_decr (out
, out_len
, upos
);
22203 case RULE_OP_MANGLE_REPLACE_NP1
:
22204 NEXT_RULEPOS (rule_pos
);
22205 NEXT_RPTOI (rule
, rule_pos
, upos
);
22206 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22209 case RULE_OP_MANGLE_REPLACE_NM1
:
22210 NEXT_RULEPOS (rule_pos
);
22211 NEXT_RPTOI (rule
, rule_pos
, upos
);
22212 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22215 case RULE_OP_MANGLE_TITLE
:
22216 out_len
= mangle_title (out
, out_len
);
22219 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22220 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22221 NEXT_RULEPOS (rule_pos
);
22222 NEXT_RPTOI (rule
, rule_pos
, upos
);
22223 NEXT_RULEPOS (rule_pos
);
22224 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22225 NEXT_RULEPOS (rule_pos
);
22226 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22227 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22230 case RULE_OP_MANGLE_APPEND_MEMORY
:
22231 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22232 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22233 memcpy (out
+ out_len
, mem
, mem_len
);
22234 out_len
+= mem_len
;
22237 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22238 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22239 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22240 memcpy (mem
+ mem_len
, out
, out_len
);
22241 out_len
+= mem_len
;
22242 memcpy (out
, mem
, out_len
);
22245 case RULE_OP_MEMORIZE_WORD
:
22246 memcpy (mem
, out
, out_len
);
22250 case RULE_OP_REJECT_LESS
:
22251 NEXT_RULEPOS (rule_pos
);
22252 NEXT_RPTOI (rule
, rule_pos
, upos
);
22253 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22256 case RULE_OP_REJECT_GREATER
:
22257 NEXT_RULEPOS (rule_pos
);
22258 NEXT_RPTOI (rule
, rule_pos
, upos
);
22259 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22262 case RULE_OP_REJECT_CONTAIN
:
22263 NEXT_RULEPOS (rule_pos
);
22264 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22267 case RULE_OP_REJECT_NOT_CONTAIN
:
22268 NEXT_RULEPOS (rule_pos
);
22269 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22272 case RULE_OP_REJECT_EQUAL_FIRST
:
22273 NEXT_RULEPOS (rule_pos
);
22274 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22277 case RULE_OP_REJECT_EQUAL_LAST
:
22278 NEXT_RULEPOS (rule_pos
);
22279 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22282 case RULE_OP_REJECT_EQUAL_AT
:
22283 NEXT_RULEPOS (rule_pos
);
22284 NEXT_RPTOI (rule
, rule_pos
, upos
);
22285 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22286 NEXT_RULEPOS (rule_pos
);
22287 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22290 case RULE_OP_REJECT_CONTAINS
:
22291 NEXT_RULEPOS (rule_pos
);
22292 NEXT_RPTOI (rule
, rule_pos
, upos
);
22293 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22294 NEXT_RULEPOS (rule_pos
);
22295 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22296 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22299 case RULE_OP_REJECT_MEMORY
:
22300 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22304 return (RULE_RC_SYNTAX_ERROR
);
22309 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);